Add files using upload-large-folder tool

parse/train/48uzkHOKMfz/48uzkHOKMfz.md

@@ -0,0 +1,198 @@
+# Accelerating Robotic Reinforcement Learning via Parameterized Action Primitives
+
+Murtaza Dalal Deepak Pathak† Ruslan Salakhutdinov† Carnegie Mellon University {mdalal,dpathak,rsalakhu} @ cs.cmu.edu
+
+# Abstract
+
+Despite the potential of reinforcement learning (RL) for building general-purpose robotic systems, training RL agents to solve robotics tasks still remains challenging due to the difficulty of exploration in purely continuous action spaces. Addressing this problem is an active area of research with the majority of focus on improving RL methods via better optimization or more efficient exploration. An alternate but important component to consider improving is the interface of the RL algorithm with the robot. In this work, we manually specify a library of robot action primitives (RAPS), parameterized with arguments that are learned by an RL policy. These parameterized primitives are expressive, simple to implement, enable efficient exploration and can be transferred across robots, tasks and environments. We perform a thorough empirical study across challenging tasks in three distinct domains with image input and a sparse terminal reward. We find that our simple change to the action interface substantially improves both the learning efficiency and task performance irrespective of the underlying RL algorithm, significantly outperforming prior methods which learn skills from offline expert data. Code and videos at https://mihdalal.github.io/raps/
+
+# 1 Introduction
+
+Meaningful exploration remains a challenge for robotic reinforcement learning systems. For example, in the manipulation tasks shown in Figure 1, useful exploration might correspond to picking up and placing objects in different configurations. However, random motions in the robot’s joint space will rarely, if ever, result in the robot touching the objects, let alone pick them up. Recent work, on the other hand, has demonstrated remarkable success in training RL agents to solve manipulation tasks [4, 24, 26] by sidestepping the exploration problem with careful engineering. Levine et al. [26] use densely shaped rewards, while Kalashnikov et al. [24] leverage a large scale robot infrastructure and Andrychowicz et al. [4] require training in simulation with engineered reward functions in order to transfer to the real world. In general, RL methods can be prohibitively data inefficient, require careful reward development to learn, and struggle to scale to more complex tasks without the aid of human demonstrations or carefully designed simulation setups.
+
+An alternative view on why RL is difficult for robotics is that it requires the agent to learn both what to do in order to achieve the task and how to control the robot to execute the desired motions. For example, in the kitchen environment featured at the bottom of Figure 1, the agent would have to learn how to accurately manipulate the arm to reach different locations as well as how to grasp different objects, while also ascertaining what object it has to grasp and where to move it. Considered independently, the problems of controlling a robot arm to execute particular motions and figuring out the desired task from scalar reward feedback, then achieving it, are non-trivial. Jointly learning to solve both problems makes the task significantly more difficult.
+
+![](images/e614f68926084e42358f98f2dd7a1b4cc8070d2d0225070eba314dc4bd22147c.jpg)  
+Figure 1: Visual depiction of RAPS, outlining the process of how a primitive is executed on a robot. Given an input image, the policy outputs a distribution over primitives and a distribution over all the arguments of all primitives, samples a primitive and selects its corresponding argument distribution parameters, indexed by which primitive was chosen, samples an argument from that distribution and executes a controller in a feedback loop on the robot for a fixed number of timesteps $( H _ { k } )$ to reach a new state. We show an example sequence of executing the lift primitive after having grasped the kettle in the Kitchen environment. The agent observes the initial (0) and final states $\boldsymbol { H _ { k } } )$ ) and receives a reward equal to the reward accumulated when executing the primitive. Below we visualize representative tasks from the three environment suites that we evaluate on.
+
+In contrast to training RL agents on raw actions such as torques or delta positions, a common strategy is to decompose the agent action space into higher (i.e., what) and lower (i.e., how) level structures. A number of existing methods have focused on designing or learning this structure, from manually architecting and fine-tuning action hierarchies [14, 27, 32, 47], to organizing agent trajectories into distinct skills [3, 20, 41, 50] to more recent work on leveraging large offline datasets in order to learn skill libraries [29, 40]. While these methods have shown success in certain settings, many of them are either too sample inefficient, do not scale well to more complex domains, or lack generality due to dependence on task relevant data.
+
+In this work, we investigate the following question: instead of learning low-level primitives, what if we were to design primitives with minimal human effort, enable their expressiveness by parameterizing them with arguments and learn to control them with a high-level policy? Such primitives have been studied extensively in task and motion planning (TAMP) literature [22] and implemented as parameterized actions [19] in RL. We apply primitive robot motions to redefine the policy-robot interface in the context of robotic reinforcement learning. These primitives include manually defined behaviors such as lift, push, top-grasp, and many others. The behavior of these primitives is parameterized by arguments that are the learned outputs of a policy network. For instance, top-grasp is parameterized by four scalar values: grasp position $\mathbf { \Phi } ( \mathbf { x } , \mathbf { y } )$ , how much to move down (z) and the degree to which the gripper should close. We call this application of parameterized behaviors, Robot Action Primitives for RL (RAPS). A crucial point to note is that these parameterized actions are easy to design, need only be defined once and can be re-used without modification across tasks.
+
+The main contribution of this work is to support the effectiveness of RAPS via a thorough empirical evaluation across several dimensions:
+
+• How do parameterized primitives compare to other forms of action parameterization? • How does RAPS compare to prior methods that learn skills from offline expert data? • Is RAPS agnostic to the underlying RL algorithm? • Can we stitch the primitives to perform multiple complex manipulation tasks in sequence? • Does RAPS accelerate exploration even in the absence of extrinsic rewards?
+
+We investigate these questions across complex manipulation environments including Kitchen Suite, Metaworld and Robosuite domains. We find that a simple parameterized action based approach outperforms prior state-of-the-art by a significant margin across most of these settings2
+
+# 2 Related Work
+
+Higher Level Action and Policy Spaces in Robotics In robotics literature, decision making over primitive actions that execute well-defined behaviors has been explored in the context of task and motion planning [9, 22, 23, 43]. However, such methods are dependent on accurate state estimation pipelines to enable planning over the argument space of primitives. One advantage of using reinforcement learning methods instead is that the agent can learn to adjust its implicit state estimates through trial and error experience. Dynamic Movement Primitive and ensuing policy search approaches [11, 21, 25, 36, 37] leverage dynamical systems to learn flexible, parameterized skills, but are sensitive to hyper-parameter tuning and often limited to the behavior cloning regime. Neural Dynamic Policies [6] incorporate dynamical structure into neural network policies for RL, but evaluate in the state based regime with dense rewards, while we show that parameterized actions can enable RL agents to efficiently explore in sparse reward settings from image input.
+
+Hierarchical RL and Skill Learning Enabling RL agents to act effectively over temporally extended horizons is a longstanding research goal in the field of hierarchical RL. Prior work introduced the options framework [45], which outlines how to leverage lower level policies as actions for a higher level policy. In this framework, parameterized action primitives can be viewed as a particular type of fixed option with an initiation set that corresponds to the arguments of the primitive. Prior work on options has focused on discovering [1, 12, 41] or fine-tuning options [5, 14, 27] in addition to learning higher level policies. Many of these methods have not been extended beyond carefully engineered state based settings. More recently, research has focused on extracting useful skills from large offline datasets of interaction data ranging from unstructured interaction data [49], play [28, 29] to demonstration data [2, 35, 39, 40, 44, 46, 53]. While these methods have been shown to be successful on certain tasks, the learned skills are only relevant for the environment they are trained on. New demonstration data must be collected to use learned skills for a new robot, a new task, or even a new camera viewpoint. Since RAPS uses manually specified primitives dependent only on the robot state, RAPS can re-use the same implementation details across robots, tasks and domains.
+
+Parameterized Actions in RL The parameterized action Markov decision process (PAMDP) formalism was first introduced in Masson et al. [31], though there is a large body of earlier work in the area of hybrid discrete-continuous control, surveyed in [7, 8]. Most recent research on PAMDPs has focused on better aligning policy architectures and RL updates with the nature of parameterized actions and has largely been limited to state based domains [13, 51]. A number of papers in this area have focused on solving a simulated robot soccer domain modeled as either a single-agent [19, 31, 48] or multi-agent [15] problem. In this paper, we consider more realistic robotics tasks that involve interaction with and manipulation of common household objects. While prior work [42] has trained RL policies to select hand-designed behaviors for simultaneous execution, we instead train RL policies to leverage more expressive, parameterized behaviors to solve a wide variety of tasks. Closely related to this work is Chitnis et al. [10], which develops a specific architecture for training policies over parameterized actions from state input and sparse rewards in the context of bi-manual robotic manipulation. Our work is orthogonal in that we demonstrate that a higher level policy architecture is sufficient to solve a large suite of manipulation tasks from image input. We additionally note that there is concurrent work [34] that also applies engineered primitives in the context of RL, however, we consider learning from image input and sparse terminal rewards.
+
+# 3 Robot Action Primitives in RL
+
+To address the challenge of exploration and behavior learning in continuous action spaces, we decompose a desired task into the what (high level task) and the how (control motion). The what is handled by the environment-centric RL policy while the how is handled by a fixed, manually defined set of agent-centric primitives parameterized by continuous arguments. This enables the high level policy to reason about the task at a high level by choosing primitives and their arguments while leaving the low-level control to the parameterized actions themselves.
+
+# 3.1 Background
+
+Let the Markov decision process (MDP) be defined as $( S , A , \mathcal { R } ( s , a , s ^ { \prime } ) , \mathcal { T } ( s ^ { \prime } | s , a ) , p ( s _ { 0 } ) , \gamma , )$ in which $s$ is the set of true states, $\mathcal { A }$ is the set of possible actions, $\mathcal { R } ( s , a , s ^ { \prime } )$ is the reward function, $\mathcal { T } ( s ^ { \prime } | s , a )$ is the transition probability distribution, $p ( s _ { 0 } )$ defines the initial state distribution, and $\gamma$ is the discount factor. The agent executes actions in the environment using a policy $\pi ( a | s )$ with a corresponding trajectory distribution $p ( \tau = ( s _ { 0 } , a _ { 0 } , . . . a _ { t - 1 } , s _ { T } ) ) = p ( s _ { 0 } ) \Pi _ { t } \pi ( a _ { t } | s _ { t } ) \mathcal { T } ( s _ { t + 1 } | s _ { t } , a _ { t } )$ . The goal of the RL agent is to maximize the expected sum of rewards with respect to the policy: $\begin{array} { r } { \mathbb { E } _ { s _ { 0 } , a _ { 0 } , \dots a _ { t - 1 } , s _ { T } , \sim p ( \tau ) } \mathsf { \bar { [ \sum _ { t } \gamma ^ { t } \mathcal { R } ( s _ { t } , a _ { t } ) ] } } } \end{array}$ . In the case of vision-based RL, the setup is now a partially observed Markov decision process (POMDP); we have access to the true state via image observations. In this case, we include an observation space $\mathcal { O }$ which corresponds to the set of visual observations that the environment may emit, an observation model $p ( o | s )$ which defines the probability of emission and policy $\pi ( a | o )$ which operates over observations. In this work, we consider various modifications to the action space $\mathcal { A }$ while keeping all other components of the MDP or POMDP the same.
+
+# 3.2 Parameterized Action Primitives
+
+We now describe the specific nature of our parameterized primitives and how they can be integrated into RL algorithms (see Figure 1 for an end-to-end visualization of the method). In a library of $K$ primitives, the $\mathbf { k }$ -th primitive is a function $f _ { k } ( s , \mathrm { a r g s } )$ that executes a controller $C _ { k }$ on a robot for a fixed horizon $H _ { k }$ , $s$ is the robot state and args is the value of the arguments passed to $f _ { k }$ . args is used to compute a target robot state $s ^ { * }$ and then $C _ { k }$ is used to drive $s$ to $s ^ { * }$ . A primitive dependent error metric $e _ { k } ( s , s ^ { * } )$ determines the trajectory $C _ { k }$ takes to reach $s ^ { * }$ . $C _ { k }$ is a general purpose state reaching controller, e.g. an end-effector or joint position controller; we assume access to such a controller for each robot and it is straightforward to define and tune if not provided. In this case, the same primitive implementation can be re-used across any robot. In this setup, the choice of controller, error metric and method to compute $s ^ { * }$ define the behavior of the primitive motion, how it uniquely forms a movement in space. We refer to Procedure 1 for a general outline of a parameterized primitive. To summarize, each skill is a feedback control loop with end-effector low level actions. The input arguments are used to define a target state to achieve and the primitive executes a loop to drive the error between the robot state and the target robot state to zero.
+
+As an example, consider the “lifting“ primitive, which simply involves lifting the robot arm upward. For this action, args is the amount to lift the robot arm, e.g. by $2 0 \mathrm { c m } .$ ., the robot state for this primitive is the robot end-effector position, $\mathbf { k }$ is the index of the lifting primitive in the library, $C _ { k }$ is an end-effector controller, $e _ { k } ( s , s ^ { * } ) = s ^ { * } - s$ , and $H _ { k }$ is the end-effector controller horizon, which in our setting ranges from 100-300. The target position $s ^ { * }$ is computed as $s + [ 0 , 0$ , args]. $f$ moves the robot arm for $H _ { k }$ steps, driving $s$ towards $s ^ { * }$ . The other primitives are defined in a similar manner; see the appendix for a precise description of each primitive we define.
+
+Robot action primitives are a function of the robot state, not the world state. The primitives function by reaching set points of the robot state as directed by the policy, hence they are agentcentric. This design makes primitives agnostic to camera view, visual distractors and even the underlying environment itself. The RL policy, on the other hand, is environment centric: it chooses the primitive and appropriate arguments based on environment observations in order to
+
+# Procedure 1 Parameterized Action Primitive
+
+Input: primitive dependent argument vector args, primitive index $k$ , robot state $s$   
+1: compute $s ^ { * } ( \mathrm { a r g s } , s )$   
+2: for $i = 1 , . . . , H _ { k }$ low-level steps do   
+3: $e _ { i } = e _ { k } ( s _ { i } , s ^ { * } )$ $\triangleright$ compute state error   
+4: $a _ { i } = C _ { k } ( e _ { i } , s _ { i } )$ . compute torques   
+5: execute $a _ { i }$ on robot   
+6: end for
+
+best achieve the task. A key advantage of this decomposition is that the policy no longer has to learn how to move the robot and can focus directly on what it needs to do. Meanwhile, the low-level control need not be perfect because the policy can account for most discrepancies using the arguments.
+
+One issue with using a fixed library of primitives is that it cannot define all possible robot motions. As a result, we include a dummy primitive that corresponds to the raw action space. The dummy primitive directly takes in a delta position and then tries to achieve it by taking a fixed number of steps. This does not entirely resolve the issue as the dummy primitive operates on the high level horizon for $H _ { k }$ steps when called. Since the primitive is given a fixed goal for $H _ { k }$ steps, it is less expressive than a feedback policy that could provide a changing argument at every low-level step. For example, if the task is to move in a circle, the dummy primitive with a fixed argument could not provide a target state that would directly result in the desired motion without resorting to a significant number of higher level actions, while a feedback policy could iteratively update the target state to produce a smooth motion in a circle. Therefore, it cannot execute every trajectory that a lower level policy could; however, the primitive library as a whole performs well in practice.
+
+In order to integrate these parameterized actions into the RL setting, we modify the action space of a standard RL environment to involve two operations at each time step: (a) choose a primitive out of a fixed library (b) output its arguments. As in Chitnis et al. [10], the policy network outputs a distribution over one-hot vectors defining which primitive to use as well as a distribution over all of the arguments for all of the primitives, a design choice which enables the policy network to have a fixed output dimension. After the policy samples an action, the chosen parameterized action and its corresponding arguments are indexed from the action and passed to the environment. The environment selects the appropriate primitive function $f$ and executes the primitive on the robot with the appropriate arguments. After the primitive completes executing, the final observation and sum of intermediate rewards during the execution of the primitive are returned by the environment. We do so to ensure if the task is achieved mid primitive execution, the action is still labelled successful.
+
+![](images/efe765ee9a3b99303a143f68f7f6fecb4d21cfe9b47261f595516ad5f66408c4.jpg)  
+Figure 2: We visualize an execution of an RL agent trained to solve a cabinet opening task from sparse rewards using robot action primitives. At each time-step, we display the primitive chosen, the policy’s confidence in the action choice and the corresponding argument passed to the primitive in the bottom left corner.
+
+We describe a concrete example to ground the description of our framework. If we have 10 primitives with 3 arguments each, the higher level policy network outputs 30 dimensional mean and standard deviation vectors from which we sample a 30 dimensional argument vector. It also outputs a 10 dimensional logit vector from which we sample a 10 dimensional one-hot vector. Therefore in total, our action space would be 40 dimensional. The environment takes in the 40 dimensional vector and selects the appropriate argument (3-dimensional vector) from the argument vector based on the one-hot vector over primitives and executes the corresponding primitive in the environment. Using this policy architecture and primitive execution format, we train standard RL agents to solve manipulation tasks from sparse rewards. See Figure 2 for a visualization of a full trajectory of a policy solving a hinge cabinet opening task in the Kitchen Suite with RAPS.
+
+# 4 Experimental Setup
+
+In order to perform a robust evaluation of robot action primitives and prior work, we select a set of challenging robotic control tasks, define our environmental setup, propose appropriate metrics for evaluating different action spaces, and summarize our baselines for comparison.
+
+Tasks and Environments: We evaluate RAPS on three simulated domains: Metaworld [17], Kitchen [52] and Robosuite [54], containing 16 tasks with varying levels of difficulty, realism and task diversity (see the bottom half of Fig. 1). We use the Kitchen environment because it contains seven different subtasks within a single setting, contains human demonstration data useful for training learned skills and contains tasks that require chaining together up to four subtasks to solve. In particular, learning such temporally-extended behavior is challenging [2, 17, 35]. Next, we evaluate on the Metaworld benchmark suite due to its wide range of manipulation tasks and established presence in the RL community. We select a subset of tasks from Metaworld (see appendix) with different solution behaviors to robustly evaluate the impact of primitives on RL. Finally, one limitation of the two previous domains is that the underlying end-effector control is implemented via a simulation constraint as opposed to true position control by applying torques to the robot. In order to evaluate if primitives would scale to more realistic learning setups, we test on Robosuite, a benchmark of robotic manipulation tasks which emphasizes realistic simulation and control. We select the block lifting and door opening environments which have been demonstrated to be solvable in prior work [54]. We refer the reader to the appendix for a detailed description of each environment.
+
+Sparse Reward and Image Observations We modify each task to use the environment success metric as a sparse reward which returns 1 when the task is achieved, and 0 otherwise. We do so in order to establish a more realistic and difficult exploration setting than dense rewards which require significant engineering effort and true state information to compute. Additionally, we plot all results against the mean task success rate since it is a directly interpretable measure of the agent’s performance. We run each method using visual input as we wish to bring our evaluation setting closer to real world setups. The higher level policy, primitives and baseline methods are not provided access to the world state, only camera observations and robot state depending on the action.
+
+Evaluation Metrics One challenge when evaluating hierarchical action spaces such as RAPS alongside a variety of different learned skills and action parameterizations, is that of defining a fair and meaningful definition of sample efficiency. We could define one sample to be a forward pass through the RL policy. For low-level actions this is exactly the sample efficiency, for higher level actions this only measures how often the policy network makes decisions, which favors actions with a large number of low-level actions without regard for controller run-time cost, which can be significant. Alternatively, we could define one sample to be a single low-level action output by a low-level controller. This metric would accurately determine how often the robot itself acts in the world, but it can make high level actions appear deceptively inefficient. Higher level actions execute far fewer forward passes of the policy in each episode which can result in faster execution on a robot when operating over visual observations, a key point low-level sample efficiency fails to account for. We experimentally verify this point by running RAPS and raw actions on a real $\mathrm { x A r m } \ : 6$ robot with visual RL and finding that RAPS executes each trajectory $\mathbf { 3 2 x }$ times faster than raw actions. We additionally verify that RAPS is efficient with respect to low level steps in Figure 4.
+
+To ensure fair comparison across methods, we instead propose to perform evaluations with respect to two metrics, namely, (a) Wall-clock Time: the amount of total time it takes to train the agent to solve the task, both interaction time and time spent updating the agent, and (b) Training Steps: the number of gradient steps taken with a fixed batch size. Wall clock time is not inherently tied to the action space and provides an interpretable number for how long it takes for the agent to learn the task. To ensure consistency, we evaluate all methods on a single RTX 2080 GPU with 10 CPUs and 50GB of memory. However, this metric is not sufficient since there are several possible factors that can influence wall clock time which can be difficult to disambiguate, such as the effect of external processes, low-level controller execution speed, and implementation dependent details. As a result, we additionally compare methods based on the number of training steps, a proxy for data efficiency. The number of network updates is only a function of the data; it is independent of the action space, machine and simulator, making it a non-transient metric for evaluation. The combination of the two metrics provides a holistic method of comparing the performance of different action spaces and skills operating on varying frequencies and horizons.
+
+Baselines The simplest baseline we consider is the default action space of the environment, which we denote as Raw Actions. One way to improve upon the raw action space is to train a policy to output the parameters of the underlying controller alongside the actual input commands. This baseline, VICES [30], enables the agent to tune the controller automatically depending on the task. Alternatively, one can use unsupervised skill extraction to generate higher level actions which can be leveraged by downstream RL. We evaluate one such method, Dyn- $\mathbf { E }$ [49], which trains an observation and action representation from random policy data such that the subsequent state is predictable from the embeddings of the previous observation and action. A more data-driven approach to learning skills involves organizing demonstration data into a latent skill space. Since the dataset is guaranteed to contain meaningful behaviors, it is more likely that the extracted skills will be useful for downstream tasks. We compare against SPIRL [35], a method that ingests a demonstration dataset to train a fixed length skill VAE $z = e ( a _ { 1 : H } ) , a _ { 1 : H } = d ( z )$ and prior over skills $p ( z | s )$ , which is used to guide downstream RL. Additionally, we compare against PARROT [44], which trains an observation conditioned flow model on an offline dataset to map from the raw action space to a latent action space. In the next section, we demonstrate the performance of our RAPS against these methods across a diverse set of sparse reward manipulation tasks.
+
+# 5 Experimental Evaluation of RAPS
+
+We evaluate the efficacy of RAPS on three different settings: single task reinforcement learning across Kitchen, Metaworld and Robosuite, as well as hierarchical control and unsupervised exploration in the Kitchen environment. We observe across all evaluated settings, RAPS is robust, efficient and performant, in direct contrast to a wide variety of learned skills and action parameterizations.
+
+![](images/e879a3118ac1ababfff61db02ef69fab84f97cb4fa943473af4a79c126459e6b.jpg)  
+Figure 3: Comparison of various action parameterizations and RAPS across all three environment suites3using Dreamer as the underlying RL algorithm. RAPS (green), with sparse rewards, is able to significantly outperform all baselines, particularly on the more challenging tasks, even when they are augmented with dense reward. See the appendix for remaining plots on the slide-cabinet and soccer-v2 tasks.
+
+![](images/ed5ca959fb7f07f53782ab1c3443101102524c20d5359a43fc240c6eb4a5a2d6.jpg)  
+Figure 4: In the Kitchen environment suite, we run comparisons logging the number of low level interactions of RAPS, Raw actions and VICES. While the methods appear closer in efficiency with respect to low-level actions, RAPS still maintains the best performance across every task. We note that on a real robot, RAPS runs significantly faster than the raw action space in terms of wall-clock time.
+
+# 5.1 Accelerating Single Task RL using RAPS
+
+In this section, we evaluate the performance of RAPS against fixed and variable transformations of the lower-level action space as well as state of the art unsupervised skill extraction from demonstrations. Due to space constraints, we show performance against the number of training steps in the appendix.
+
+Action Parameterizations We compare RAPS against Raw Actions and VICES using Dreamer [18] as the underlying algorithm across all three environment suites in Figure 3. Since we observe weak performance on the default action space of Kitchen, joint velocity control, we instead modify the suite to use 6DOF end-effector control for both raw actions and VICES. We find Raw Actions and VICES are able to make progress on a number of tasks across all three domains, but struggle to execute the fine-grained manipulation required to solve more difficult environments such as hinge-cabinet, assembly-v2 and disassembly-v2. The latter two environments are not solved by Raw Actions or VICES even when they are provided dense rewards. In contrast, RAPS is able to quickly solve every task from sparse rewards.
+
+On the kitchen environment, from sparse rewards, no prior method makes progress on the hardest manipulation task: grasping the hinge cabinet and pulling it open to 90 degrees, while RAPS is able to quickly learn to solve the task. In the Metaworld domain, peg-unplug-side-v2, assembly-v2 and disassembly-v2 are difficult environments which present a challenge to even dense reward state based RL [52]. However, RAPS is able to solve all three tasks with sparse rewards directly from image input. We additionally include a comparison of RAPS against Raw Actions on all 50 Metaworld tasks with final performance shown in Figure 6 as well as the full learning performance in the Appendix. RAPS is able to learn to solve or make progress on 43 out of 50 tasks purely from sparse rewards. Finally, in the Robosuite domain, by leveraging robot action primitives, we are able to learn to solve the tasks more rapidly than raw actions or VICES, with respect to wall-clock time and number of training steps, demonstrating that RAPS scales to more realistic robotic controllers.
+
+![](images/1beb979a93352e371b5369b8e1b96fc0f71e3d3e87ad60143029db346c4b6417.jpg)  
+Figure 5: Comparison of RAPS and skill learning methods on the Kitchen domain using SAC as the underlying RL algorithm. While SPIRL and PARROT are competitive or even improve upon RAPS’s performance on easier tasks, only RAPS (green) is able to solve top-left-burner and hinge-cabinet.
+
+Table 1: Evaluation of RAPS across RL algorithms (Dreamer, PPO, SAC) on Kitchen. We report the final success rate of each method on five evaluation trials trained over three seeds from sparse rewards. While raw action performance (left entry) varies significantly across RL algorithms, RAPS (right entry) is able to achieve high success rates on every task with every RL algorithm.   
+
+<table><tr><td rowspan=2 colspan=1>RL Algorithm</td><td rowspan=2 colspan=12>Kettle    Slide CabinetLight Switch Microwave  Top Burner Hinge CabinetRaw RAPS Raw RAPS Raw RAPS Raw RAPS Raw RAPS Raw RAPS</td></tr><tr><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td></tr><tr><td rowspan=1 colspan=1>Dreamer</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>.93</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.53</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>.93</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>1.0</td></tr><tr><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>.67</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.86</td><td rowspan=1 colspan=1>.67</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>1.0</td></tr><tr><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.66</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.27</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>.66</td><td rowspan=1 colspan=1>.27</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>1.0</td></tr></table>
+
+Offline Learned Skills An alternative point of comparison is to leverage offline data to learn skills and run downstream RL. We train SPIRL and PARROT from images using the kitchen demonstration datasets in D4RL [16], and Dyn-E with random interaction data. We run all agents with SAC as the underlying RL algorithm and extract learned skills using joint velocity control, the type of action present in the demonstrations. See Figure 5 for the comparison of RAPS against learned skills. Dyn-E is unable to make progress across any of the domains due to the difficulty of extracting useful skills from highly unstructured interaction data. In contrast, SPIRL and PARROT manage to leverage demonstration data to extract useful skills; they are competitive or even improve upon RAPS on the easier tasks such as microwave and kettle, but struggle to make progress on the more difficult tasks in the suite. PARROT, in particular, exhibits a great deal of variance across tasks, especially with SAC, so we include results using Dreamer as well. We note that both SPIRL and PARROT are limited by the tasks which are present in the demonstration dataset and unable to generalize their extracted skills to other tasks in the same environment or other domains. In contrast, parameterized primitives are able to solve all the kitchen tasks and are re-used across domains as shown in Figure 3.
+
+Generalization to different RL algorithms A generic set of skills should maintain performance regardless of the underlying RL algorithm. In this section, we evaluate the performance of RAPS against Raw Actions on three types of RL algorithms: model based (Dreamer), off-policy model free (SAC) and on-policy model free (PPO) on the Kitchen tasks. We use the end-effector version of raw actions as our point of comparison on these tasks. As seen in Table 1, unlike raw actions, RAPS is largely agnostic to the underlying RL algorithm.
+
+# 5.2 Enabling Hierarchical Control via RAPS
+
+We next apply RAPS to a more complex setting: sequential RL, in which the agent must learn to solve multiple subtasks within a single episode, as opposed to one task. We evaluate on the Kitchen Multi-Task environments and plot performance across SAC, Dreamer, and PPO in Figure 7.
+
+![](images/88134cf6330a3e7cce1f6ac5e9b73ce0556bb75797492920fc80f7eedb49e6ca.jpg)  
+Figure 6: Final performance results for single task RL on the Metaworld domain after 3 days of training using the Dreamer base algorithm. RAPS is able to successfully learn most tasks, solving 43 out of 50 tasks while Raw Actions is only able to solve 21 tasks.
+
+![](images/f91aef47a11d4c00510750e156d79454264b37d0686bccb001cb98b6204fc7f0.jpg)  
+Figure 7: Learning performance of RAPS on sequential multi-task RL. Each row plots a different base RL algorithm (SAC, Dreamer, PPO) while the first two columns plot the two multi-task environment results against wall-clock time and the next two columns plot against number of updates, i.e. training steps. RAPS consistently solves at least three out of four subtasks while prior methods generally fail to make progress beyond one or two.
+
+Raw Actions prove to be a strong baseline, eventually solving close to three subtasks on average, while requiring significantly more wall-clock time and training steps. SPIRL initially shows strong performance but after solving one to two subtasks it then plateaus and fails to improve. PARROT is less efficient than SPIRL but also able to make progress on up to two subtasks, though it exhibits a great deal of sensitivity to the underlying RL algorithm. For both of the offline skill learning methods, they struggle to solve any of the subtasks outside of kettle, microwave, and slide-cabinet which are encompassed in the demonstration dataset. Meanwhile, with RAPS, across all three base RL algorithms, we observe that the agents are able to leverage the primitive library to rapidly solve three out of four subtasks and continue to improve. This result demonstrates that RAPS can elicit significant gains in hierarchical RL performance through its improved exploratory behavior.
+
+![](images/b44b0d74463208ab327bfbcc5f57c5fc16103db92a1bf28a4e48c5e058d29c00.jpg)  
+Figure 8: RAPS significantly outperforms raw actions in terms of total wall clock time and number of updates when fine-tuning initialized from reward free exploration.
+
+# 5.3 Leveraging RAPS to enable efficient unsupervised exploration
+
+In many settings, sparse rewards themselves can be hard to come by. Ideally, we would be able to train robot without train time task rewards for large periods of time and fine-tune to solve new tasks with only a few supervised labels. We use the kitchen environment to test the efficacy of primitives on the task of unsupervised exploration. We run an unsupervised exploration algorithm, Plan2explore [38], for a fixed number of steps to learn a world model, and then fine-tune the model and train a policy using Dreamer to solve specific tasks. We plot the results in Figure 8 on the top-left-burner and hinge-cabinet tasks. RAPS enables the agent to learn an effective world model that results in rapid learning of both tasks, requiring only 1 hour of fine-tuning to solve the hinge-cabinet task. Meanwhile, the world model learned by exploring with raw actions is unable to quickly finetune as quickly. We draw two conclusions from these results, a) RAPS enables more efficient exploration than raw actions, b) RAPS facilitates efficient model fitting, resulting in rapid fine-tuning.
+
+# 6 Discussion
+
+Limitations and Future Work While we demonstrate that RAPS is effective at solving a diverse array of manipulation tasks from visual input, there are several limitations that future work would need to address. One issue to consider is that of dynamic, fluid motions. Currently, once a primitive begins executing, it will not stop until its horizon is complete, which prevents dynamic behavior that a feedback policy on the raw action space could achieve. In the context of RAPS, integrating the parameterization and environment agnostic properties of robot action primitives with standard feedback policies could be one way to scale RAPS to more dynamic tasks. Another potential concern is that of expressivity: the set of primitives we consider in this work cannot express all possible motions that robot might need to execute. As discussed in Section 3, we do combine the base actions with primitives via a dummy primitive so that the policy can fall back to default action space if necessary. Future work could improve upon our simple solution. Finally, more complicated robot morphologies may require significant domain knowledge in order to design primitive behaviors. In this setting, we believe that learned skills with the agent-centric structure of robot action primitives could be an effective way to balance between the difficulty of learning policies to control complex robot morphologies [4, 33] and the time needed to manually define primitives.
+
+Conclusion In this work we present an extensive evaluation of RAPS, which leverages parameterized actions to learn high level policies that can quickly solve robotics tasks across three different environment suites. We show that standard methods of re-parameterizing the action space and learning skills from demonstrations are environment and domain dependent. In many cases, prior methods are unable to match the performance of robot action primitives. While primitives are not a general solution to every task, their success across a wide range of environments illustrates the utility of incorporating an agent-centric structure into the robot action space. Given the effectiveness of simple parameterized action primitives, a promising direction to further investigate would be how to best incorporate agent-centric structure into both learned and manually defined skills and attempt to get the best of both worlds in order to improve the interface of RL algorithms with robots.
+
+Acknowledgments We thank Shikhar Bahl, Ben Eyesenbach, Aravind Sivakumar, Rishi Veerapaneni, Russell Mendonca and Paul Liang for feedback on early drafts of this paper. This work was supported in part by NSF IIS1763562, NSF IIS-2024594, and ONR Grant N000141812861, and the US Army. Additionally, MD is supported by the NSF Graduate Fellowship. We would also like to acknowledge NVIDIA’s GPU support.
+
+# References
+
+[1] J. Achiam, H. Edwards, D. Amodei, and P. Abbeel. Variational option discovery algorithms. arXiv preprint arXiv:1807.10299, 2018. 3   
+[2] A. Ajay, A. Kumar, P. Agrawal, S. Levine, and O. Nachum. Opal: Offline primitive discovery for accelerating offline reinforcement learning, 2021. 3, 5   
+[3] A. Allshire, R. Martín-Martín, C. Lin, S. Manuel, S. Savarese, and A. Garg. Laser: Learning a latent action space for efficient reinforcement learning. arXiv preprint arXiv:2103.15793, 2021. 2   
+[4] O. M. Andrychowicz, B. Baker, M. Chociej, R. Jozefowicz, B. McGrew, J. Pachocki, A. Petron, M. Plappert, G. Powell, A. Ray, et al. Learning dexterous in-hand manipulation. The International Journal of Robotics Research, 39(1):3–20, 2020. 1, 10   
+[5] P.-L. Bacon, J. Harb, and D. Precup. The option-critic architecture. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 31, 2017. 3   
+[6] S. Bahl, M. Mukadam, A. Gupta, and D. Pathak. Neural dynamic policies for end-to-end sensorimotor learning, 2020. 3   
+[7] A. Bemporad and M. Morari. Control of systems integrating logic, dynamics, and constraints. Automatica, 35(3):407–427, 1999. 3   
+[8] M. S. Branicky, V. S. Borkar, and S. K. Mitter. A unified framework for hybrid control: Model and optimal control theory. IEEE transactions on automatic control, 43(1):31–45, 1998. 3   
+[9] S. Cambon, R. Alami, and F. Gravot. A hybrid approach to intricate motion, manipulation and task planning. The International Journal of Robotics Research, 28(1):104–126, 2009. 3   
+[10] R. Chitnis, S. Tulsiani, S. Gupta, and A. Gupta. Efficient bimanual manipulation using learned task schemas. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 1149–1155. IEEE, 2020. 3, 5   
+[11] C. Daniel, G. Neumann, O. Kroemer, J. Peters, et al. Hierarchical relative entropy policy search. Journal of Machine Learning Research, 17:1–50, 2016. 3   
+[12] B. Eysenbach, A. Gupta, J. Ibarz, and S. Levine. Diversity is all you need: Learning skills without a reward function. arXiv preprint arXiv:1802.06070, 2018. 3   
+[13] Z. Fan, R. Su, W. Zhang, and Y. Yu. Hybrid actor-critic reinforcement learning in parameterized action space. arXiv preprint arXiv:1903.01344, 2019. 3   
+[14] K. Frans, J. Ho, X. Chen, P. Abbeel, and J. Schulman. Meta learning shared hierarchies. arXiv preprint arXiv:1710.09767, 2017. 2, 3   
+[15] H. Fu, H. Tang, J. Hao, Z. Lei, Y. Chen, and C. Fan. Deep multi-agent reinforcement learning with discrete-continuous hybrid action spaces. arXiv preprint arXiv:1903.04959, 2019. 3   
+[16] J. Fu, A. Kumar, O. Nachum, G. Tucker, and S. Levine. D4rl: Datasets for deep data-driven reinforcement learning, 2021. 8   
+[17] A. Gupta, V. Kumar, C. Lynch, S. Levine, and K. Hausman. Relay policy learning: Solving long-horizon tasks via imitation and reinforcement learning, 2019. 5   
+[18] D. Hafner, T. Lillicrap, J. Ba, and M. Norouzi. Dream to control: Learning behaviors by latent imagination, 2020. 7   
+[19] M. Hausknecht and P. Stone. Deep reinforcement learning in parameterized action space. arXiv preprint arXiv:1511.04143, 2015. 2, 3   
+[20] K. Hausman, J. T. Springenberg, Z. Wang, N. Heess, and M. Riedmiller. Learning an embedding space for transferable robot skills. In International Conference on Learning Representations, 2018. 2   
+[21] A. J. Ijspeert, J. Nakanishi, and S. Schaal. Learning attractor landscapes for learning motor primitives. Technical report, 2002. 3   
+[22] L. P. Kaelbling and T. Lozano-Pérez. Hierarchical task and motion planning in the now. In 2011 IEEE International Conference on Robotics and Automation, pages 1470–1477. IEEE, 2011. 2, 3   
+[23] L. P. Kaelbling and T. Lozano-Pérez. Learning composable models of parameterized skills. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pages 886–893. IEEE, 2017. 3   
+[24] D. Kalashnikov, A. Irpan, P. Pastor, J. Ibarz, A. Herzog, E. Jang, D. Quillen, E. Holly, M. Kalakrishnan, V. Vanhoucke, et al. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. arXiv preprint arXiv:1806.10293, 2018. 1   
+[25] J. Kober and J. Peters. Learning motor primitives for robotics. In 2009 IEEE International Conference on Robotics and Automation, pages 2112–2118. IEEE, 2009. 3   
+[26] S. Levine, C. Finn, T. Darrell, and P. Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016. 1   
+[27] A. C. Li, C. Florensa, I. Clavera, and P. Abbeel. Sub-policy adaptation for hierarchical reinforcement learning. arXiv preprint arXiv:1906.05862, 2019. 2, 3   
+[28] C. Lynch and P. Sermanet. Grounding language in play. arXiv preprint arXiv:2005.07648, 2020. 3   
+[29] C. Lynch, M. Khansari, T. Xiao, V. Kumar, J. Tompson, S. Levine, and P. Sermanet. Learning latent plans from play. In Conference on Robot Learning, pages 1113–1132. PMLR, 2020. 2, 3   
+[30] R. Martín-Martín, M. A. Lee, R. Gardner, S. Savarese, J. Bohg, and A. Garg. Variable impedance control in end-effector space: An action space for reinforcement learning in contact-rich tasks, 2019. 6   
+[31] W. Masson, P. Ranchod, and G. Konidaris. Reinforcement learning with parameterized actions. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016. 3   
+[32] O. Nachum, S. Gu, H. Lee, and S. Levine. Data-efficient hierarchical reinforcement learning. arXiv preprint arXiv:1805.08296, 2018. 2   
+[33] A. Nagabandi, K. Konolige, S. Levine, and V. Kumar. Deep dynamics models for learning dexterous manipulation. In Conference on Robot Learning, pages 1101–1112. PMLR, 2020. 10   
+[34] S. Nasiriany, H. Liu, and Y. Zhu. Augmenting reinforcement learning with behavior primitives for diverse manipulation tasks, 2021. 3   
+[35] K. Pertsch, Y. Lee, and J. J. Lim. Accelerating reinforcement learning with learned skill priors, 2020. 3, 5, 6   
+[36] J. Peters, K. Mulling, and Y. Altun. Relative entropy policy search. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 24, 2010. 3   
+[37] S. Schaal. Dynamic movement primitives-a framework for motor control in humans and humanoid robotics. In Adaptive motion of animals and machines, pages 261–280. Springer, 2006. 3   
+[38] R. Sekar, O. Rybkin, K. Daniilidis, P. Abbeel, D. Hafner, and D. Pathak. Planning to explore via self-supervised world models, 2020. 10   
+[39] T. Shankar and A. Gupta. Learning robot skills with temporal variational inference. In International Conference on Machine Learning, pages 8624–8633. PMLR, 2020. 3   
+[40] T. Shankar, S. Tulsiani, L. Pinto, and A. Gupta. Discovering motor programs by recomposing demonstrations. In International Conference on Learning Representations, 2019. 2, 3   
+[41] A. Sharma, S. Gu, S. Levine, V. Kumar, and K. Hausman. Dynamics-aware unsupervised discovery of skills. arXiv preprint arXiv:1907.01657, 2019. 2, 3   
+[42] M. Sharma, J. Liang, J. Zhao, A. LaGrassa, and O. Kroemer. Learning to compose hierarchical object-centric controllers for robotic manipulation. arXiv preprint arXiv:2011.04627, 2020. 3   
+[43] A. Simeonov, Y. Du, B. Kim, F. R. Hogan, J. Tenenbaum, P. Agrawal, and A. Rodriguez. A long horizon planning framework for manipulating rigid pointcloud objects. arXiv preprint arXiv:2011.08177, 2020. 3   
+[44] A. Singh, H. Liu, G. Zhou, A. Yu, N. Rhinehart, and S. Levine. Parrot: Data-driven behavioral priors for reinforcement learning. arXiv preprint arXiv:2011.10024, 2020. 3, 6   
+[45] R. S. Sutton, D. Precup, and S. Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999. 3   
+[46] D. Tanneberg, K. Ploeger, E. Rueckert, and J. Peters. Skid raw: Skill discovery from raw trajectories. IEEE Robotics and Automation Letters, 6(3):4696–4703, 2021. 3   
+[47] A. S. Vezhnevets, S. Osindero, T. Schaul, N. Heess, M. Jaderberg, D. Silver, and K. Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. In International Conference on Machine Learning, pages 3540–3549. PMLR, 2017. 2   
+[48] E. Wei, D. Wicke, and S. Luke. Hierarchical approaches for reinforcement learning in parameterized action space. arXiv preprint arXiv:1810.09656, 2018. 3   
+[49] W. Whitney, R. Agarwal, K. Cho, and A. Gupta. Dynamics-aware embeddings, 2020. 3, 6   
+[50] K. Xie, H. Bharadhwaj, D. Hafner, A. Garg, and F. Shkurti. Latent skill planning for exploration and transfer. In International Conference on Learning Representations, 2020. 2   
+[51] J. Xiong, Q. Wang, Z. Yang, P. Sun, L. Han, Y. Zheng, H. Fu, T. Zhang, J. Liu, and H. Liu. Parametrized deep q-networks learning: Reinforcement learning with discrete-continuous hybrid action space. arXiv preprint arXiv:1810.06394, 2018. 3   
+[52] T. Yu, D. Quillen, Z. He, R. Julian, K. Hausman, C. Finn, and S. Levine. Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on Robot Learning, pages 1094–1100. PMLR, 2020. 5, 8   
+[53] W. Zhou, S. Bajracharya, and D. Held. Plas: Latent action space for offline reinforcement learning. arXiv preprint arXiv:2011.07213, 2020. 3   
+[54] Y. Zhu, J. Wong, A. Mandlekar, and R. Martín-Martín. robosuite: A modular simulation framework and benchmark for robot learning, 2020. 5

parse/train/48uzkHOKMfz/48uzkHOKMfz_content_list.json

@@ -0,0 +1,835 @@
+[
+    {
+        "type": "text",
+        "text": "Accelerating Robotic Reinforcement Learning via Parameterized Action Primitives ",
+        "text_level": 1,
+        "bbox": [
+            199,
+            122,
+            799,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Murtaza Dalal Deepak Pathak† Ruslan Salakhutdinov† Carnegie Mellon University {mdalal,dpathak,rsalakhu} @ cs.cmu.edu ",
+        "bbox": [
+            290,
+            220,
+            741,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            299,
+            535,
+            315
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the potential of reinforcement learning (RL) for building general-purpose robotic systems, training RL agents to solve robotics tasks still remains challenging due to the difficulty of exploration in purely continuous action spaces. Addressing this problem is an active area of research with the majority of focus on improving RL methods via better optimization or more efficient exploration. An alternate but important component to consider improving is the interface of the RL algorithm with the robot. In this work, we manually specify a library of robot action primitives (RAPS), parameterized with arguments that are learned by an RL policy. These parameterized primitives are expressive, simple to implement, enable efficient exploration and can be transferred across robots, tasks and environments. We perform a thorough empirical study across challenging tasks in three distinct domains with image input and a sparse terminal reward. We find that our simple change to the action interface substantially improves both the learning efficiency and task performance irrespective of the underlying RL algorithm, significantly outperforming prior methods which learn skills from offline expert data. Code and videos at https://mihdalal.github.io/raps/ ",
+        "bbox": [
+            233,
+            332,
+            764,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            310,
+            598
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Meaningful exploration remains a challenge for robotic reinforcement learning systems. For example, in the manipulation tasks shown in Figure 1, useful exploration might correspond to picking up and placing objects in different configurations. However, random motions in the robot’s joint space will rarely, if ever, result in the robot touching the objects, let alone pick them up. Recent work, on the other hand, has demonstrated remarkable success in training RL agents to solve manipulation tasks [4, 24, 26] by sidestepping the exploration problem with careful engineering. Levine et al. [26] use densely shaped rewards, while Kalashnikov et al. [24] leverage a large scale robot infrastructure and Andrychowicz et al. [4] require training in simulation with engineered reward functions in order to transfer to the real world. In general, RL methods can be prohibitively data inefficient, require careful reward development to learn, and struggle to scale to more complex tasks without the aid of human demonstrations or carefully designed simulation setups. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            757
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An alternative view on why RL is difficult for robotics is that it requires the agent to learn both what to do in order to achieve the task and how to control the robot to execute the desired motions. For example, in the kitchen environment featured at the bottom of Figure 1, the agent would have to learn how to accurately manipulate the arm to reach different locations as well as how to grasp different objects, while also ascertaining what object it has to grasp and where to move it. Considered independently, the problems of controlling a robot arm to execute particular motions and figuring out the desired task from scalar reward feedback, then achieving it, are non-trivial. Jointly learning to solve both problems makes the task significantly more difficult. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/e614f68926084e42358f98f2dd7a1b4cc8070d2d0225070eba314dc4bd22147c.jpg",
+        "image_caption": [
+            "Figure 1: Visual depiction of RAPS, outlining the process of how a primitive is executed on a robot. Given an input image, the policy outputs a distribution over primitives and a distribution over all the arguments of all primitives, samples a primitive and selects its corresponding argument distribution parameters, indexed by which primitive was chosen, samples an argument from that distribution and executes a controller in a feedback loop on the robot for a fixed number of timesteps $( H _ { k } )$ to reach a new state. We show an example sequence of executing the lift primitive after having grasped the kettle in the Kitchen environment. The agent observes the initial (0) and final states $\\boldsymbol { H _ { k } } )$ ) and receives a reward equal to the reward accumulated when executing the primitive. Below we visualize representative tasks from the three environment suites that we evaluate on. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            89,
+            805,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In contrast to training RL agents on raw actions such as torques or delta positions, a common strategy is to decompose the agent action space into higher (i.e., what) and lower (i.e., how) level structures. A number of existing methods have focused on designing or learning this structure, from manually architecting and fine-tuning action hierarchies [14, 27, 32, 47], to organizing agent trajectories into distinct skills [3, 20, 41, 50] to more recent work on leveraging large offline datasets in order to learn skill libraries [29, 40]. While these methods have shown success in certain settings, many of them are either too sample inefficient, do not scale well to more complex domains, or lack generality due to dependence on task relevant data. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            554
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we investigate the following question: instead of learning low-level primitives, what if we were to design primitives with minimal human effort, enable their expressiveness by parameterizing them with arguments and learn to control them with a high-level policy? Such primitives have been studied extensively in task and motion planning (TAMP) literature [22] and implemented as parameterized actions [19] in RL. We apply primitive robot motions to redefine the policy-robot interface in the context of robotic reinforcement learning. These primitives include manually defined behaviors such as lift, push, top-grasp, and many others. The behavior of these primitives is parameterized by arguments that are the learned outputs of a policy network. For instance, top-grasp is parameterized by four scalar values: grasp position $\\mathbf { \\Phi } ( \\mathbf { x } , \\mathbf { y } )$ , how much to move down (z) and the degree to which the gripper should close. We call this application of parameterized behaviors, Robot Action Primitives for RL (RAPS). A crucial point to note is that these parameterized actions are easy to design, need only be defined once and can be re-used without modification across tasks. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            726
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of this work is to support the effectiveness of RAPS via a thorough empirical evaluation across several dimensions: ",
+        "bbox": [
+            173,
+            732,
+            823,
+            761
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• How do parameterized primitives compare to other forms of action parameterization? • How does RAPS compare to prior methods that learn skills from offline expert data? • Is RAPS agnostic to the underlying RL algorithm? • Can we stitch the primitives to perform multiple complex manipulation tasks in sequence? • Does RAPS accelerate exploration even in the absence of extrinsic rewards? ",
+        "bbox": [
+            184,
+            766,
+            790,
+            837
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We investigate these questions across complex manipulation environments including Kitchen Suite, Metaworld and Robosuite domains. We find that a simple parameterized action based approach outperforms prior state-of-the-art by a significant margin across most of these settings2 ",
+        "bbox": [
+            176,
+            843,
+            826,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Higher Level Action and Policy Spaces in Robotics In robotics literature, decision making over primitive actions that execute well-defined behaviors has been explored in the context of task and motion planning [9, 22, 23, 43]. However, such methods are dependent on accurate state estimation pipelines to enable planning over the argument space of primitives. One advantage of using reinforcement learning methods instead is that the agent can learn to adjust its implicit state estimates through trial and error experience. Dynamic Movement Primitive and ensuing policy search approaches [11, 21, 25, 36, 37] leverage dynamical systems to learn flexible, parameterized skills, but are sensitive to hyper-parameter tuning and often limited to the behavior cloning regime. Neural Dynamic Policies [6] incorporate dynamical structure into neural network policies for RL, but evaluate in the state based regime with dense rewards, while we show that parameterized actions can enable RL agents to efficiently explore in sparse reward settings from image input. ",
+        "bbox": [
+            173,
+            113,
+            825,
+            265
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical RL and Skill Learning Enabling RL agents to act effectively over temporally extended horizons is a longstanding research goal in the field of hierarchical RL. Prior work introduced the options framework [45], which outlines how to leverage lower level policies as actions for a higher level policy. In this framework, parameterized action primitives can be viewed as a particular type of fixed option with an initiation set that corresponds to the arguments of the primitive. Prior work on options has focused on discovering [1, 12, 41] or fine-tuning options [5, 14, 27] in addition to learning higher level policies. Many of these methods have not been extended beyond carefully engineered state based settings. More recently, research has focused on extracting useful skills from large offline datasets of interaction data ranging from unstructured interaction data [49], play [28, 29] to demonstration data [2, 35, 39, 40, 44, 46, 53]. While these methods have been shown to be successful on certain tasks, the learned skills are only relevant for the environment they are trained on. New demonstration data must be collected to use learned skills for a new robot, a new task, or even a new camera viewpoint. Since RAPS uses manually specified primitives dependent only on the robot state, RAPS can re-use the same implementation details across robots, tasks and domains. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Parameterized Actions in RL The parameterized action Markov decision process (PAMDP) formalism was first introduced in Masson et al. [31], though there is a large body of earlier work in the area of hybrid discrete-continuous control, surveyed in [7, 8]. Most recent research on PAMDPs has focused on better aligning policy architectures and RL updates with the nature of parameterized actions and has largely been limited to state based domains [13, 51]. A number of papers in this area have focused on solving a simulated robot soccer domain modeled as either a single-agent [19, 31, 48] or multi-agent [15] problem. In this paper, we consider more realistic robotics tasks that involve interaction with and manipulation of common household objects. While prior work [42] has trained RL policies to select hand-designed behaviors for simultaneous execution, we instead train RL policies to leverage more expressive, parameterized behaviors to solve a wide variety of tasks. Closely related to this work is Chitnis et al. [10], which develops a specific architecture for training policies over parameterized actions from state input and sparse rewards in the context of bi-manual robotic manipulation. Our work is orthogonal in that we demonstrate that a higher level policy architecture is sufficient to solve a large suite of manipulation tasks from image input. We additionally note that there is concurrent work [34] that also applies engineered primitives in the context of RL, however, we consider learning from image input and sparse terminal rewards. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Robot Action Primitives in RL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            460,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To address the challenge of exploration and behavior learning in continuous action spaces, we decompose a desired task into the what (high level task) and the how (control motion). The what is handled by the environment-centric RL policy while the how is handled by a fixed, manually defined set of agent-centric primitives parameterized by continuous arguments. This enables the high level policy to reason about the task at a high level by choosing primitives and their arguments while leaving the low-level control to the parameterized actions themselves. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            299,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let the Markov decision process (MDP) be defined as $( S , A , \\mathcal { R } ( s , a , s ^ { \\prime } ) , \\mathcal { T } ( s ^ { \\prime } | s , a ) , p ( s _ { 0 } ) , \\gamma , )$ in which $s$ is the set of true states, $\\mathcal { A }$ is the set of possible actions, $\\mathcal { R } ( s , a , s ^ { \\prime } )$ is the reward function, $\\mathcal { T } ( s ^ { \\prime } | s , a )$ is the transition probability distribution, $p ( s _ { 0 } )$ defines the initial state distribution, and $\\gamma$ is the discount factor. The agent executes actions in the environment using a policy $\\pi ( a | s )$ with a corresponding trajectory distribution $p ( \\tau = ( s _ { 0 } , a _ { 0 } , . . . a _ { t - 1 } , s _ { T } ) ) = p ( s _ { 0 } ) \\Pi _ { t } \\pi ( a _ { t } | s _ { t } ) \\mathcal { T } ( s _ { t + 1 } | s _ { t } , a _ { t } )$ . The goal of the RL agent is to maximize the expected sum of rewards with respect to the policy: $\\begin{array} { r } { \\mathbb { E } _ { s _ { 0 } , a _ { 0 } , \\dots a _ { t - 1 } , s _ { T } , \\sim p ( \\tau ) } \\mathsf { \\bar { [ \\sum _ { t } \\gamma ^ { t } \\mathcal { R } ( s _ { t } , a _ { t } ) ] } } } \\end{array}$ . In the case of vision-based RL, the setup is now a partially observed Markov decision process (POMDP); we have access to the true state via image observations. In this case, we include an observation space $\\mathcal { O }$ which corresponds to the set of visual observations that the environment may emit, an observation model $p ( o | s )$ which defines the probability of emission and policy $\\pi ( a | o )$ which operates over observations. In this work, we consider various modifications to the action space $\\mathcal { A }$ while keeping all other components of the MDP or POMDP the same. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            203
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Parameterized Action Primitives ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            212,
+            441,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now describe the specific nature of our parameterized primitives and how they can be integrated into RL algorithms (see Figure 1 for an end-to-end visualization of the method). In a library of $K$ primitives, the $\\mathbf { k }$ -th primitive is a function $f _ { k } ( s , \\mathrm { a r g s } )$ that executes a controller $C _ { k }$ on a robot for a fixed horizon $H _ { k }$ , $s$ is the robot state and args is the value of the arguments passed to $f _ { k }$ . args is used to compute a target robot state $s ^ { * }$ and then $C _ { k }$ is used to drive $s$ to $s ^ { * }$ . A primitive dependent error metric $e _ { k } ( s , s ^ { * } )$ determines the trajectory $C _ { k }$ takes to reach $s ^ { * }$ . $C _ { k }$ is a general purpose state reaching controller, e.g. an end-effector or joint position controller; we assume access to such a controller for each robot and it is straightforward to define and tune if not provided. In this case, the same primitive implementation can be re-used across any robot. In this setup, the choice of controller, error metric and method to compute $s ^ { * }$ define the behavior of the primitive motion, how it uniquely forms a movement in space. We refer to Procedure 1 for a general outline of a parameterized primitive. To summarize, each skill is a feedback control loop with end-effector low level actions. The input arguments are used to define a target state to achieve and the primitive executes a loop to drive the error between the robot state and the target robot state to zero. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As an example, consider the “lifting“ primitive, which simply involves lifting the robot arm upward. For this action, args is the amount to lift the robot arm, e.g. by $2 0 \\mathrm { c m } .$ ., the robot state for this primitive is the robot end-effector position, $\\mathbf { k }$ is the index of the lifting primitive in the library, $C _ { k }$ is an end-effector controller, $e _ { k } ( s , s ^ { * } ) = s ^ { * } - s$ , and $H _ { k }$ is the end-effector controller horizon, which in our setting ranges from 100-300. The target position $s ^ { * }$ is computed as $s + [ 0 , 0$ , args]. $f$ moves the robot arm for $H _ { k }$ steps, driving $s$ towards $s ^ { * }$ . The other primitives are defined in a similar manner; see the appendix for a precise description of each primitive we define. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Robot action primitives are a function of the robot state, not the world state. The primitives function by reaching set points of the robot state as directed by the policy, hence they are agentcentric. This design makes primitives agnostic to camera view, visual distractors and even the underlying environment itself. The RL policy, on the other hand, is environment centric: it chooses the primitive and appropriate arguments based on environment observations in order to ",
+        "bbox": [
+            174,
+            539,
+            485,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Procedure 1 Parameterized Action Primitive ",
+        "text_level": 1,
+        "bbox": [
+            500,
+            551,
+            792,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: primitive dependent argument vector args, primitive index $k$ , robot state $s$   \n1: compute $s ^ { * } ( \\mathrm { a r g s } , s )$   \n2: for $i = 1 , . . . , H _ { k }$ low-level steps do   \n3: $e _ { i } = e _ { k } ( s _ { i } , s ^ { * } )$ $\\triangleright$ compute state error   \n4: $a _ { i } = C _ { k } ( e _ { i } , s _ { i } )$ . compute torques   \n5: execute $a _ { i }$ on robot   \n6: end for ",
+        "bbox": [
+            501,
+            566,
+            825,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "best achieve the task. A key advantage of this decomposition is that the policy no longer has to learn how to move the robot and can focus directly on what it needs to do. Meanwhile, the low-level control need not be perfect because the policy can account for most discrepancies using the arguments. ",
+        "bbox": [
+            176,
+            676,
+            821,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One issue with using a fixed library of primitives is that it cannot define all possible robot motions. As a result, we include a dummy primitive that corresponds to the raw action space. The dummy primitive directly takes in a delta position and then tries to achieve it by taking a fixed number of steps. This does not entirely resolve the issue as the dummy primitive operates on the high level horizon for $H _ { k }$ steps when called. Since the primitive is given a fixed goal for $H _ { k }$ steps, it is less expressive than a feedback policy that could provide a changing argument at every low-level step. For example, if the task is to move in a circle, the dummy primitive with a fixed argument could not provide a target state that would directly result in the desired motion without resorting to a significant number of higher level actions, while a feedback policy could iteratively update the target state to produce a smooth motion in a circle. Therefore, it cannot execute every trajectory that a lower level policy could; however, the primitive library as a whole performs well in practice. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to integrate these parameterized actions into the RL setting, we modify the action space of a standard RL environment to involve two operations at each time step: (a) choose a primitive out of a fixed library (b) output its arguments. As in Chitnis et al. [10], the policy network outputs a distribution over one-hot vectors defining which primitive to use as well as a distribution over all of the arguments for all of the primitives, a design choice which enables the policy network to have a fixed output dimension. After the policy samples an action, the chosen parameterized action and its corresponding arguments are indexed from the action and passed to the environment. The environment selects the appropriate primitive function $f$ and executes the primitive on the robot with the appropriate arguments. After the primitive completes executing, the final observation and sum of intermediate rewards during the execution of the primitive are returned by the environment. We do so to ensure if the task is achieved mid primitive execution, the action is still labelled successful. ",
+        "bbox": [
+            173,
+            883,
+            820,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/efe765ee9a3b99303a143f68f7f6fecb4d21cfe9b47261f595516ad5f66408c4.jpg",
+        "image_caption": [
+            "Figure 2: We visualize an execution of an RL agent trained to solve a cabinet opening task from sparse rewards using robot action primitives. At each time-step, we display the primitive chosen, the policy’s confidence in the action choice and the corresponding argument passed to the primitive in the bottom left corner. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            89,
+            821,
+            181
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            250,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We describe a concrete example to ground the description of our framework. If we have 10 primitives with 3 arguments each, the higher level policy network outputs 30 dimensional mean and standard deviation vectors from which we sample a 30 dimensional argument vector. It also outputs a 10 dimensional logit vector from which we sample a 10 dimensional one-hot vector. Therefore in total, our action space would be 40 dimensional. The environment takes in the 40 dimensional vector and selects the appropriate argument (3-dimensional vector) from the argument vector based on the one-hot vector over primitives and executes the corresponding primitive in the environment. Using this policy architecture and primitive execution format, we train standard RL agents to solve manipulation tasks from sparse rewards. See Figure 2 for a visualization of a full trajectory of a policy solving a hinge cabinet opening task in the Kitchen Suite with RAPS. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            542,
+            372,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to perform a robust evaluation of robot action primitives and prior work, we select a set of challenging robotic control tasks, define our environmental setup, propose appropriate metrics for evaluating different action spaces, and summarize our baselines for comparison. ",
+        "bbox": [
+            174,
+            566,
+            823,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Tasks and Environments: We evaluate RAPS on three simulated domains: Metaworld [17], Kitchen [52] and Robosuite [54], containing 16 tasks with varying levels of difficulty, realism and task diversity (see the bottom half of Fig. 1). We use the Kitchen environment because it contains seven different subtasks within a single setting, contains human demonstration data useful for training learned skills and contains tasks that require chaining together up to four subtasks to solve. In particular, learning such temporally-extended behavior is challenging [2, 17, 35]. Next, we evaluate on the Metaworld benchmark suite due to its wide range of manipulation tasks and established presence in the RL community. We select a subset of tasks from Metaworld (see appendix) with different solution behaviors to robustly evaluate the impact of primitives on RL. Finally, one limitation of the two previous domains is that the underlying end-effector control is implemented via a simulation constraint as opposed to true position control by applying torques to the robot. In order to evaluate if primitives would scale to more realistic learning setups, we test on Robosuite, a benchmark of robotic manipulation tasks which emphasizes realistic simulation and control. We select the block lifting and door opening environments which have been demonstrated to be solvable in prior work [54]. We refer the reader to the appendix for a detailed description of each environment. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Sparse Reward and Image Observations We modify each task to use the environment success metric as a sparse reward which returns 1 when the task is achieved, and 0 otherwise. We do so in order to establish a more realistic and difficult exploration setting than dense rewards which require significant engineering effort and true state information to compute. Additionally, we plot all results against the mean task success rate since it is a directly interpretable measure of the agent’s performance. We run each method using visual input as we wish to bring our evaluation setting closer to real world setups. The higher level policy, primitives and baseline methods are not provided access to the world state, only camera observations and robot state depending on the action. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            821,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics One challenge when evaluating hierarchical action spaces such as RAPS alongside a variety of different learned skills and action parameterizations, is that of defining a fair and meaningful definition of sample efficiency. We could define one sample to be a forward pass through the RL policy. For low-level actions this is exactly the sample efficiency, for higher level actions this only measures how often the policy network makes decisions, which favors actions with a large number of low-level actions without regard for controller run-time cost, which can be significant. Alternatively, we could define one sample to be a single low-level action output by a low-level controller. This metric would accurately determine how often the robot itself acts in the world, but it can make high level actions appear deceptively inefficient. Higher level actions execute far fewer forward passes of the policy in each episode which can result in faster execution on a robot when operating over visual observations, a key point low-level sample efficiency fails to account for. We experimentally verify this point by running RAPS and raw actions on a real $\\mathrm { x A r m } \\ : 6$ robot with visual RL and finding that RAPS executes each trajectory $\\mathbf { 3 2 x }$ times faster than raw actions. We additionally verify that RAPS is efficient with respect to low level steps in Figure 4. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            320
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To ensure fair comparison across methods, we instead propose to perform evaluations with respect to two metrics, namely, (a) Wall-clock Time: the amount of total time it takes to train the agent to solve the task, both interaction time and time spent updating the agent, and (b) Training Steps: the number of gradient steps taken with a fixed batch size. Wall clock time is not inherently tied to the action space and provides an interpretable number for how long it takes for the agent to learn the task. To ensure consistency, we evaluate all methods on a single RTX 2080 GPU with 10 CPUs and 50GB of memory. However, this metric is not sufficient since there are several possible factors that can influence wall clock time which can be difficult to disambiguate, such as the effect of external processes, low-level controller execution speed, and implementation dependent details. As a result, we additionally compare methods based on the number of training steps, a proxy for data efficiency. The number of network updates is only a function of the data; it is independent of the action space, machine and simulator, making it a non-transient metric for evaluation. The combination of the two metrics provides a holistic method of comparing the performance of different action spaces and skills operating on varying frequencies and horizons. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines The simplest baseline we consider is the default action space of the environment, which we denote as Raw Actions. One way to improve upon the raw action space is to train a policy to output the parameters of the underlying controller alongside the actual input commands. This baseline, VICES [30], enables the agent to tune the controller automatically depending on the task. Alternatively, one can use unsupervised skill extraction to generate higher level actions which can be leveraged by downstream RL. We evaluate one such method, Dyn- $\\mathbf { E }$ [49], which trains an observation and action representation from random policy data such that the subsequent state is predictable from the embeddings of the previous observation and action. A more data-driven approach to learning skills involves organizing demonstration data into a latent skill space. Since the dataset is guaranteed to contain meaningful behaviors, it is more likely that the extracted skills will be useful for downstream tasks. We compare against SPIRL [35], a method that ingests a demonstration dataset to train a fixed length skill VAE $z = e ( a _ { 1 : H } ) , a _ { 1 : H } = d ( z )$ and prior over skills $p ( z | s )$ , which is used to guide downstream RL. Additionally, we compare against PARROT [44], which trains an observation conditioned flow model on an offline dataset to map from the raw action space to a latent action space. In the next section, we demonstrate the performance of our RAPS against these methods across a diverse set of sparse reward manipulation tasks. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            747
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experimental Evaluation of RAPS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            770,
+            493,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the efficacy of RAPS on three different settings: single task reinforcement learning across Kitchen, Metaworld and Robosuite, as well as hierarchical control and unsupervised exploration in the Kitchen environment. We observe across all evaluated settings, RAPS is robust, efficient and performant, in direct contrast to a wide variety of learned skills and action parameterizations. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            862
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e879a3118ac1ababfff61db02ef69fab84f97cb4fa943473af4a79c126459e6b.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of various action parameterizations and RAPS across all three environment suites3using Dreamer as the underlying RL algorithm. RAPS (green), with sparse rewards, is able to significantly outperform all baselines, particularly on the more challenging tasks, even when they are augmented with dense reward. See the appendix for remaining plots on the slide-cabinet and soccer-v2 tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            82,
+            818,
+            407
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed5ca959fb7f07f53782ab1c3443101102524c20d5359a43fc240c6eb4a5a2d6.jpg",
+        "image_caption": [
+            "Figure 4: In the Kitchen environment suite, we run comparisons logging the number of low level interactions of RAPS, Raw actions and VICES. While the methods appear closer in efficiency with respect to low-level actions, RAPS still maintains the best performance across every task. We note that on a real robot, RAPS runs significantly faster than the raw action space in terms of wall-clock time. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            479,
+            816,
+            594
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Accelerating Single Task RL using RAPS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            681,
+            500,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the performance of RAPS against fixed and variable transformations of the lower-level action space as well as state of the art unsupervised skill extraction from demonstrations. Due to space constraints, we show performance against the number of training steps in the appendix. ",
+        "bbox": [
+            174,
+            704,
+            823,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Action Parameterizations We compare RAPS against Raw Actions and VICES using Dreamer [18] as the underlying algorithm across all three environment suites in Figure 3. Since we observe weak performance on the default action space of Kitchen, joint velocity control, we instead modify the suite to use 6DOF end-effector control for both raw actions and VICES. We find Raw Actions and VICES are able to make progress on a number of tasks across all three domains, but struggle to execute the fine-grained manipulation required to solve more difficult environments such as hinge-cabinet, assembly-v2 and disassembly-v2. The latter two environments are not solved by Raw Actions or VICES even when they are provided dense rewards. In contrast, RAPS is able to quickly solve every task from sparse rewards. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the kitchen environment, from sparse rewards, no prior method makes progress on the hardest manipulation task: grasping the hinge cabinet and pulling it open to 90 degrees, while RAPS is able to quickly learn to solve the task. In the Metaworld domain, peg-unplug-side-v2, assembly-v2 and disassembly-v2 are difficult environments which present a challenge to even dense reward state based RL [52]. However, RAPS is able to solve all three tasks with sparse rewards directly from image input. We additionally include a comparison of RAPS against Raw Actions on all 50 Metaworld tasks with final performance shown in Figure 6 as well as the full learning performance in the Appendix. RAPS is able to learn to solve or make progress on 43 out of 50 tasks purely from sparse rewards. Finally, in the Robosuite domain, by leveraging robot action primitives, we are able to learn to solve the tasks more rapidly than raw actions or VICES, with respect to wall-clock time and number of training steps, demonstrating that RAPS scales to more realistic robotic controllers. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1beb979a93352e371b5369b8e1b96fc0f71e3d3e87ad60143029db346c4b6417.jpg",
+        "image_caption": [
+            "Figure 5: Comparison of RAPS and skill learning methods on the Kitchen domain using SAC as the underlying RL algorithm. While SPIRL and PARROT are competitive or even improve upon RAPS’s performance on easier tasks, only RAPS (green) is able to solve top-left-burner and hinge-cabinet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            85,
+            818,
+            196
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9ece6bcb7e478e2e6785733ac9072427f4b749053943208f9198555a3f39585.jpg",
+        "table_caption": [
+            "Table 1: Evaluation of RAPS across RL algorithms (Dreamer, PPO, SAC) on Kitchen. We report the final success rate of each method on five evaluation trials trained over three seeds from sparse rewards. While raw action performance (left entry) varies significantly across RL algorithms, RAPS (right entry) is able to achieve high success rates on every task with every RL algorithm. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>RL Algorithm</td><td rowspan=2 colspan=12>Kettle    Slide CabinetLight Switch Microwave  Top Burner Hinge CabinetRaw RAPS Raw RAPS Raw RAPS Raw RAPS Raw RAPS Raw RAPS</td></tr><tr><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td><td rowspan=1 colspan=1>RAPS</td><td rowspan=1 colspan=1>Raw</td></tr><tr><td rowspan=1 colspan=1>Dreamer</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>.93</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.53</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>.93</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>1.0</td></tr><tr><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>.67</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.86</td><td rowspan=1 colspan=1>.67</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>1.0</td></tr><tr><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>.33</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.66</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>.27</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>.66</td><td rowspan=1 colspan=1>.27</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>1.0</td></tr></table>",
+        "bbox": [
+            173,
+            257,
+            823,
+            337
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            421,
+            825,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Offline Learned Skills An alternative point of comparison is to leverage offline data to learn skills and run downstream RL. We train SPIRL and PARROT from images using the kitchen demonstration datasets in D4RL [16], and Dyn-E with random interaction data. We run all agents with SAC as the underlying RL algorithm and extract learned skills using joint velocity control, the type of action present in the demonstrations. See Figure 5 for the comparison of RAPS against learned skills. Dyn-E is unable to make progress across any of the domains due to the difficulty of extracting useful skills from highly unstructured interaction data. In contrast, SPIRL and PARROT manage to leverage demonstration data to extract useful skills; they are competitive or even improve upon RAPS on the easier tasks such as microwave and kettle, but struggle to make progress on the more difficult tasks in the suite. PARROT, in particular, exhibits a great deal of variance across tasks, especially with SAC, so we include results using Dreamer as well. We note that both SPIRL and PARROT are limited by the tasks which are present in the demonstration dataset and unable to generalize their extracted skills to other tasks in the same environment or other domains. In contrast, parameterized primitives are able to solve all the kitchen tasks and are re-used across domains as shown in Figure 3. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generalization to different RL algorithms A generic set of skills should maintain performance regardless of the underlying RL algorithm. In this section, we evaluate the performance of RAPS against Raw Actions on three types of RL algorithms: model based (Dreamer), off-policy model free (SAC) and on-policy model free (PPO) on the Kitchen tasks. We use the end-effector version of raw actions as our point of comparison on these tasks. As seen in Table 1, unlike raw actions, RAPS is largely agnostic to the underlying RL algorithm. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Enabling Hierarchical Control via RAPS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            848,
+            498,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We next apply RAPS to a more complex setting: sequential RL, in which the agent must learn to solve multiple subtasks within a single episode, as opposed to one task. We evaluate on the Kitchen Multi-Task environments and plot performance across SAC, Dreamer, and PPO in Figure 7. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/88134cf6330a3e7cce1f6ac5e9b73ce0556bb75797492920fc80f7eedb49e6ca.jpg",
+        "image_caption": [
+            "Figure 6: Final performance results for single task RL on the Metaworld domain after 3 days of training using the Dreamer base algorithm. RAPS is able to successfully learn most tasks, solving 43 out of 50 tasks while Raw Actions is only able to solve 21 tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            826,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/f91aef47a11d4c00510750e156d79454264b37d0686bccb001cb98b6204fc7f0.jpg",
+        "image_caption": [
+            "Figure 7: Learning performance of RAPS on sequential multi-task RL. Each row plots a different base RL algorithm (SAC, Dreamer, PPO) while the first two columns plot the two multi-task environment results against wall-clock time and the next two columns plot against number of updates, i.e. training steps. RAPS consistently solves at least three out of four subtasks while prior methods generally fail to make progress beyond one or two. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            366,
+            807,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Raw Actions prove to be a strong baseline, eventually solving close to three subtasks on average, while requiring significantly more wall-clock time and training steps. SPIRL initially shows strong performance but after solving one to two subtasks it then plateaus and fails to improve. PARROT is less efficient than SPIRL but also able to make progress on up to two subtasks, though it exhibits a great deal of sensitivity to the underlying RL algorithm. For both of the offline skill learning methods, they struggle to solve any of the subtasks outside of kettle, microwave, and slide-cabinet which are encompassed in the demonstration dataset. Meanwhile, with RAPS, across all three base RL algorithms, we observe that the agents are able to leverage the primitive library to rapidly solve three out of four subtasks and continue to improve. This result demonstrates that RAPS can elicit significant gains in hierarchical RL performance through its improved exploratory behavior. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b44b0d74463208ab327bfbcc5f57c5fc16103db92a1bf28a4e48c5e058d29c00.jpg",
+        "image_caption": [
+            "Figure 8: RAPS significantly outperforms raw actions in terms of total wall clock time and number of updates when fine-tuning initialized from reward free exploration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            85,
+            818,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 Leveraging RAPS to enable efficient unsupervised exploration ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            256,
+            643,
+            271
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In many settings, sparse rewards themselves can be hard to come by. Ideally, we would be able to train robot without train time task rewards for large periods of time and fine-tune to solve new tasks with only a few supervised labels. We use the kitchen environment to test the efficacy of primitives on the task of unsupervised exploration. We run an unsupervised exploration algorithm, Plan2explore [38], for a fixed number of steps to learn a world model, and then fine-tune the model and train a policy using Dreamer to solve specific tasks. We plot the results in Figure 8 on the top-left-burner and hinge-cabinet tasks. RAPS enables the agent to learn an effective world model that results in rapid learning of both tasks, requiring only 1 hour of fine-tuning to solve the hinge-cabinet task. Meanwhile, the world model learned by exploring with raw actions is unable to quickly finetune as quickly. We draw two conclusions from these results, a) RAPS enables more efficient exploration than raw actions, b) RAPS facilitates efficient model fitting, resulting in rapid fine-tuning. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            429
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            452,
+            292,
+            468
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations and Future Work While we demonstrate that RAPS is effective at solving a diverse array of manipulation tasks from visual input, there are several limitations that future work would need to address. One issue to consider is that of dynamic, fluid motions. Currently, once a primitive begins executing, it will not stop until its horizon is complete, which prevents dynamic behavior that a feedback policy on the raw action space could achieve. In the context of RAPS, integrating the parameterization and environment agnostic properties of robot action primitives with standard feedback policies could be one way to scale RAPS to more dynamic tasks. Another potential concern is that of expressivity: the set of primitives we consider in this work cannot express all possible motions that robot might need to execute. As discussed in Section 3, we do combine the base actions with primitives via a dummy primitive so that the policy can fall back to default action space if necessary. Future work could improve upon our simple solution. Finally, more complicated robot morphologies may require significant domain knowledge in order to design primitive behaviors. In this setting, we believe that learned skills with the agent-centric structure of robot action primitives could be an effective way to balance between the difficulty of learning policies to control complex robot morphologies [4, 33] and the time needed to manually define primitives. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conclusion In this work we present an extensive evaluation of RAPS, which leverages parameterized actions to learn high level policies that can quickly solve robotics tasks across three different environment suites. We show that standard methods of re-parameterizing the action space and learning skills from demonstrations are environment and domain dependent. In many cases, prior methods are unable to match the performance of robot action primitives. While primitives are not a general solution to every task, their success across a wide range of environments illustrates the utility of incorporating an agent-centric structure into the robot action space. Given the effectiveness of simple parameterized action primitives, a promising direction to further investigate would be how to best incorporate agent-centric structure into both learned and manually defined skills and attempt to get the best of both worlds in order to improve the interface of RL algorithms with robots. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            827
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments We thank Shikhar Bahl, Ben Eyesenbach, Aravind Sivakumar, Rishi Veerapaneni, Russell Mendonca and Paul Liang for feedback on early drafts of this paper. This work was supported in part by NSF IIS1763562, NSF IIS-2024594, and ONR Grant N000141812861, and the US Army. Additionally, MD is supported by the NSF Graduate Fellowship. We would also like to acknowledge NVIDIA’s GPU support. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] J. Achiam, H. Edwards, D. Amodei, and P. Abbeel. Variational option discovery algorithms. arXiv preprint arXiv:1807.10299, 2018. 3   \n[2] A. Ajay, A. Kumar, P. Agrawal, S. Levine, and O. Nachum. Opal: Offline primitive discovery for accelerating offline reinforcement learning, 2021. 3, 5   \n[3] A. Allshire, R. Martín-Martín, C. Lin, S. Manuel, S. Savarese, and A. Garg. Laser: Learning a latent action space for efficient reinforcement learning. arXiv preprint arXiv:2103.15793, 2021. 2   \n[4] O. M. Andrychowicz, B. Baker, M. Chociej, R. Jozefowicz, B. McGrew, J. Pachocki, A. Petron, M. Plappert, G. Powell, A. Ray, et al. Learning dexterous in-hand manipulation. The International Journal of Robotics Research, 39(1):3–20, 2020. 1, 10   \n[5] P.-L. Bacon, J. Harb, and D. Precup. The option-critic architecture. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 31, 2017. 3   \n[6] S. Bahl, M. Mukadam, A. Gupta, and D. Pathak. Neural dynamic policies for end-to-end sensorimotor learning, 2020. 3   \n[7] A. Bemporad and M. Morari. Control of systems integrating logic, dynamics, and constraints. Automatica, 35(3):407–427, 1999. 3   \n[8] M. S. Branicky, V. S. Borkar, and S. K. Mitter. A unified framework for hybrid control: Model and optimal control theory. IEEE transactions on automatic control, 43(1):31–45, 1998. 3   \n[9] S. Cambon, R. Alami, and F. Gravot. A hybrid approach to intricate motion, manipulation and task planning. The International Journal of Robotics Research, 28(1):104–126, 2009. 3   \n[10] R. Chitnis, S. Tulsiani, S. Gupta, and A. Gupta. Efficient bimanual manipulation using learned task schemas. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 1149–1155. IEEE, 2020. 3, 5   \n[11] C. Daniel, G. Neumann, O. Kroemer, J. Peters, et al. Hierarchical relative entropy policy search. Journal of Machine Learning Research, 17:1–50, 2016. 3   \n[12] B. Eysenbach, A. Gupta, J. Ibarz, and S. Levine. Diversity is all you need: Learning skills without a reward function. arXiv preprint arXiv:1802.06070, 2018. 3   \n[13] Z. Fan, R. Su, W. Zhang, and Y. Yu. Hybrid actor-critic reinforcement learning in parameterized action space. arXiv preprint arXiv:1903.01344, 2019. 3   \n[14] K. Frans, J. Ho, X. Chen, P. Abbeel, and J. Schulman. Meta learning shared hierarchies. arXiv preprint arXiv:1710.09767, 2017. 2, 3   \n[15] H. Fu, H. Tang, J. Hao, Z. Lei, Y. Chen, and C. Fan. Deep multi-agent reinforcement learning with discrete-continuous hybrid action spaces. arXiv preprint arXiv:1903.04959, 2019. 3   \n[16] J. Fu, A. Kumar, O. Nachum, G. Tucker, and S. Levine. D4rl: Datasets for deep data-driven reinforcement learning, 2021. 8   \n[17] A. Gupta, V. Kumar, C. Lynch, S. Levine, and K. Hausman. Relay policy learning: Solving long-horizon tasks via imitation and reinforcement learning, 2019. 5   \n[18] D. Hafner, T. Lillicrap, J. Ba, and M. Norouzi. Dream to control: Learning behaviors by latent imagination, 2020. 7   \n[19] M. Hausknecht and P. Stone. Deep reinforcement learning in parameterized action space. arXiv preprint arXiv:1511.04143, 2015. 2, 3   \n[20] K. Hausman, J. T. Springenberg, Z. Wang, N. Heess, and M. Riedmiller. Learning an embedding space for transferable robot skills. In International Conference on Learning Representations, 2018. 2   \n[21] A. J. Ijspeert, J. Nakanishi, and S. Schaal. Learning attractor landscapes for learning motor primitives. Technical report, 2002. 3   \n[22] L. P. Kaelbling and T. Lozano-Pérez. Hierarchical task and motion planning in the now. In 2011 IEEE International Conference on Robotics and Automation, pages 1470–1477. IEEE, 2011. 2, 3   \n[23] L. P. Kaelbling and T. Lozano-Pérez. Learning composable models of parameterized skills. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pages 886–893. IEEE, 2017. 3   \n[24] D. Kalashnikov, A. Irpan, P. Pastor, J. Ibarz, A. Herzog, E. Jang, D. Quillen, E. Holly, M. Kalakrishnan, V. Vanhoucke, et al. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. arXiv preprint arXiv:1806.10293, 2018. 1   \n[25] J. Kober and J. Peters. Learning motor primitives for robotics. In 2009 IEEE International Conference on Robotics and Automation, pages 2112–2118. IEEE, 2009. 3   \n[26] S. Levine, C. Finn, T. Darrell, and P. Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016. 1   \n[27] A. C. Li, C. Florensa, I. Clavera, and P. Abbeel. Sub-policy adaptation for hierarchical reinforcement learning. arXiv preprint arXiv:1906.05862, 2019. 2, 3   \n[28] C. Lynch and P. Sermanet. Grounding language in play. arXiv preprint arXiv:2005.07648, 2020. 3   \n[29] C. Lynch, M. Khansari, T. Xiao, V. Kumar, J. Tompson, S. Levine, and P. Sermanet. Learning latent plans from play. In Conference on Robot Learning, pages 1113–1132. PMLR, 2020. 2, 3   \n[30] R. Martín-Martín, M. A. Lee, R. Gardner, S. Savarese, J. Bohg, and A. Garg. Variable impedance control in end-effector space: An action space for reinforcement learning in contact-rich tasks, 2019. 6   \n[31] W. Masson, P. Ranchod, and G. Konidaris. Reinforcement learning with parameterized actions. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016. 3   \n[32] O. Nachum, S. Gu, H. Lee, and S. Levine. Data-efficient hierarchical reinforcement learning. arXiv preprint arXiv:1805.08296, 2018. 2   \n[33] A. Nagabandi, K. Konolige, S. Levine, and V. Kumar. Deep dynamics models for learning dexterous manipulation. In Conference on Robot Learning, pages 1101–1112. PMLR, 2020. 10   \n[34] S. Nasiriany, H. Liu, and Y. Zhu. Augmenting reinforcement learning with behavior primitives for diverse manipulation tasks, 2021. 3   \n[35] K. Pertsch, Y. Lee, and J. J. Lim. Accelerating reinforcement learning with learned skill priors, 2020. 3, 5, 6   \n[36] J. Peters, K. Mulling, and Y. Altun. Relative entropy policy search. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 24, 2010. 3   \n[37] S. Schaal. Dynamic movement primitives-a framework for motor control in humans and humanoid robotics. In Adaptive motion of animals and machines, pages 261–280. Springer, 2006. 3   \n[38] R. Sekar, O. Rybkin, K. Daniilidis, P. Abbeel, D. Hafner, and D. Pathak. Planning to explore via self-supervised world models, 2020. 10   \n[39] T. Shankar and A. Gupta. Learning robot skills with temporal variational inference. In International Conference on Machine Learning, pages 8624–8633. PMLR, 2020. 3   \n[40] T. Shankar, S. Tulsiani, L. Pinto, and A. Gupta. Discovering motor programs by recomposing demonstrations. In International Conference on Learning Representations, 2019. 2, 3   \n[41] A. Sharma, S. Gu, S. Levine, V. Kumar, and K. Hausman. Dynamics-aware unsupervised discovery of skills. arXiv preprint arXiv:1907.01657, 2019. 2, 3   \n[42] M. Sharma, J. Liang, J. Zhao, A. LaGrassa, and O. Kroemer. Learning to compose hierarchical object-centric controllers for robotic manipulation. arXiv preprint arXiv:2011.04627, 2020. 3   \n[43] A. Simeonov, Y. Du, B. Kim, F. R. Hogan, J. Tenenbaum, P. Agrawal, and A. Rodriguez. A long horizon planning framework for manipulating rigid pointcloud objects. arXiv preprint arXiv:2011.08177, 2020. 3   \n[44] A. Singh, H. Liu, G. Zhou, A. Yu, N. Rhinehart, and S. Levine. Parrot: Data-driven behavioral priors for reinforcement learning. arXiv preprint arXiv:2011.10024, 2020. 3, 6   \n[45] R. S. Sutton, D. Precup, and S. Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999. 3   \n[46] D. Tanneberg, K. Ploeger, E. Rueckert, and J. Peters. Skid raw: Skill discovery from raw trajectories. IEEE Robotics and Automation Letters, 6(3):4696–4703, 2021. 3   \n[47] A. S. Vezhnevets, S. Osindero, T. Schaul, N. Heess, M. Jaderberg, D. Silver, and K. Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. In International Conference on Machine Learning, pages 3540–3549. PMLR, 2017. 2   \n[48] E. Wei, D. Wicke, and S. Luke. Hierarchical approaches for reinforcement learning in parameterized action space. arXiv preprint arXiv:1810.09656, 2018. 3   \n[49] W. Whitney, R. Agarwal, K. Cho, and A. Gupta. Dynamics-aware embeddings, 2020. 3, 6   \n[50] K. Xie, H. Bharadhwaj, D. Hafner, A. Garg, and F. Shkurti. Latent skill planning for exploration and transfer. In International Conference on Learning Representations, 2020. 2   \n[51] J. Xiong, Q. Wang, Z. Yang, P. Sun, L. Han, Y. Zheng, H. Fu, T. Zhang, J. Liu, and H. Liu. Parametrized deep q-networks learning: Reinforcement learning with discrete-continuous hybrid action space. arXiv preprint arXiv:1810.06394, 2018. 3   \n[52] T. Yu, D. Quillen, Z. He, R. Julian, K. Hausman, C. Finn, and S. Levine. Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on Robot Learning, pages 1094–1100. PMLR, 2020. 5, 8   \n[53] W. Zhou, S. Bajracharya, and D. Held. Plas: Latent action space for offline reinforcement learning. arXiv preprint arXiv:2011.07213, 2020. 3   \n[54] Y. Zhu, J. Wong, A. Mandlekar, and R. Martín-Martín. robosuite: A modular simulation framework and benchmark for robot learning, 2020. 5 ",
+        "bbox": [
+            171,
+            97,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            78,
+            828,
+            919
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            85,
+            828,
+            657
+        ],
+        "page_idx": 12
+    }
+]

parse/train/Bkgk624KDB/Bkgk624KDB.md

@@ -0,0 +1,310 @@
+# LEARNING EFFECTIVE EXPLORATION STRATEGIES FOR CONTEXTUAL BANDITS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In contextual bandits, an algorithm must choose actions given observed contexts, learning from a reward signal that is observed only for the action chosen. This leads to an exploration/exploitation trade-off: the algorithm must balance taking actions it already believes are good with taking new actions to potentially discover better choices. We develop a meta-learning algorithm, MELˆ EE´ , that learns an exploration policy based on simulated, synthetic contextual bandit tasks. MELˆ EE´ uses imitation learning against these simulations to train an exploration policy that can be applied to true contextual bandit tasks at test time. We evaluate on both a natural contextual bandit problem derived from a learning to rank dataset as well as hundreds of simulated contextual bandit problems derived from classification tasks. MELˆ EE´ outperforms seven strong baselines on most of these datasets by leveraging a rich feature representation for learning an exploration strategy.
+
+# 1 INTRODUCTION
+
+In a contextual bandit problem, an agent attempts to optimize its behavior over a sequence of rounds based on limited feedback (Kaelbling, 1994; Auer, 2003; Langford & Zhang, 2008). In each round, the agent chooses an action based on a context (features) for that round, and observes a reward for that action but no others $( \ S 2 )$ . Contextual bandit problems arise in many real-world settings like online recommendations and personalized medicine. As in reinforcement learning, the agent must learn to balance exploitation (taking actions that, based on past experience, it believes will lead to high instantaneous reward) and exploration (trying actions that it knows less about).
+
+In this paper, we present a meta-learning approach to automatically learn a good exploration mechanism from data. To achieve this, we use synthetic supervised learning data sets on which we can simulate contextual bandit tasks in an offline setting. Based on these simulations, our algorithm, MELˆ EE´ (MEta LEarner for Exploration)1, learns a good heuristic exploration strategy that should ideally generalize to future contextual bandit problems. MELˆ EE´ contrasts with more classical approaches to exploration (like $\epsilon$ -greedy or LinUCB; see $\ S 6$ ), in which exploration strategies are constructed by expert algorithm designers. These approaches often achieve provably good exploration strategies in the worst case, but are potentially overly pessimistic and are sometimes computationally intractable.
+
+At training time (§ 3.2), MELˆ EE´ simulates many contextual bandit problems from fully labeled synthetic data. Using this data, in each round, MELˆ EE´ is able to counterfactually simulate what would happen under all possible action choices. We can then use this information to compute regret estimates for each action, which can be optimized using the AggreVaTe imitation learning algorithm (Ross & Bagnell, 2014). Our imitation learning strategy mirrors that of the meta-learning approach of Bachman et al. (2017) in the active learning setting. We present a simplified, stylized analysis of the behavior of MELˆ EE´ to ensure that our cost function encourages good behavior $( \ S 4 )$ . Empirically, we use MELˆ EE´ to train an exploration policy on only synthetic datasets and evaluate this policy on both a contextual bandit task based on a natural learning to rank dataset as well as three hundred simulated contextual bandit tasks (§5.2). We compare the trained policy to a number of alternative exploration algorithms, and show the efficacy of our approach (§5.3).
+
+# 2 PRELIMINARIES: CONTEXTUAL BANDITS AND POLICY OPTIMIZATION
+
+Contextual bandits is a model of interaction in which an agent chooses actions (based on contexts) and receives immediate rewards for that action alone. For example, in a simplified news personalization setting, at each time step $t$ , a user arrives and the system must choose a news article to display to them. Each possible news article corresponds to an action $a$ , and the user corresponds to a context $x _ { t }$ . After the system chooses an article $a _ { t }$ to display, it can observe, for instance, the amount of time that the user spends reading that article, which it can use as a reward $r _ { t } ( a _ { t } )$ .
+
+Formally, we largely follow the setup and notation of Agarwal et al. (2014). Let $\mathcal { X }$ be an input space of contexts (users) and $[ K ] = \bar { \{ 1 , \dots , K \} }$ be a finite action space (articles). We consider the statistical setting in which there exists a fixed but unknown distribution $\mathcal { D }$ over pairs $( x , r ) \in$ $\mathcal { X } \times [ 0 , 1 ] ^ { K }$ , where $\pmb { r }$ is a vector of rewards (for convenience, we assume all rewards are bounded in $[ 0 , 1 ] )$ . In this setting, the world operates iteratively over rounds $t = 1 , 2 , \ldots .$ Each round $t$ :
+
+1. The world draws $( x _ { t } , r _ { t } ) \sim \mathcal { D }$ and reveals context $x _ { t }$ .   
+2. The agent (randomly) chooses action $a _ { t } \in [ K ]$ based on $x _ { t }$ , and observes reward $r _ { t } ( a _ { t } )$ .
+
+The goal of an algorithm is to maximize the cumulative sum of rewards over time. Typically the primary quantity considered is the average regret of a sequence of actions $a _ { 1 } , \dots , a _ { T }$ to the behavior of the best possible function in a prespecified class $\mathcal { F }$ :
+
+$$
+\lambda ( a _ { 1 } , \ldots , a _ { T } ) = \operatorname* { m a x } _ { f \in { \mathcal { F } } } { \frac { 1 } { T } } \sum _ { t = 1 } ^ { T } \left[ r _ { t } ( f ( x _ { t } ) ) - r _ { t } ( a _ { t } ) \right]
+$$
+
+An agent is call no-regret if its average regret is zero in the limit of large $T$
+
+To produce a good agent for interacting with the world, we assume access to a function class $\mathcal { F }$ and to an oracle policy optimizer for that function class. For example, $\mathcal { F }$ may be a set of single layer neural networks mapping user features $x \in \mathcal { X }$ to predicted rewards for actions $a \in [ K ]$ . Formally, the observable record of interaction resulting from round $t$ is the tuple $( x _ { t } , a _ { t } , r _ { t } ( \bar { a } _ { t } ) , p _ { t } ( a _ { t } ) ) \ \in$ $\mathcal { X } { \times } [ K ] { \times } [ 0 , 1 ] { \times } [ 0 , 1 ]$ , where $p _ { t } ( a _ { t } )$ is the probability that the agent chose action $a _ { t }$ , and the full history of interaction is $h _ { t } = \langle ( x _ { i } , a _ { i } , r _ { i } ( a _ { i } ) , p _ { i } ( a _ { i } ) ) \rangle _ { i = 1 } ^ { t }$ . The oracle policy optimizer, POLOPT, takes as input a history of user interactions and outputs an $f \in { \mathcal { F } }$ with low expected regret.
+
+A standard example of a policy optimizer is to combine inverse propensity scaling (IPS) with a regression algorithm (Dudik et al., 2011). Here, given a history $h$ , each tuple $( x , a , r , p )$ in that history is mapped to a multiple-output regression example. The input for this regression example is the same $x$ ; the output is a vector of $K$ costs, all of which are zero except the $a ^ { \mathrm { { t h } } }$ component, which takes value $r / p$ . This mapping is done for all tuples in the history, and a supervised learning algorithm on the function class $\mathcal { F }$ is used to produce a low-regret regressor $f$ . This is the function returned by the policy optimizer. IPS, and other estimators that have lower-variance than IPS (such as the doubly-robust estimator), have the property of being unbiased. In experiments, we use the direct method (Dudik et al., 2011) largely for its simplicity, however, MELˆ EE´ is agnostic to the type of the estimator used by the policy optimizer.
+
+# 3 APPROACH: LEARNING AND EFFECTIVE EXPLORATION STRATEGY
+
+In order to have an effective approach to the contextual bandit problem, one must be able to both optimize a policy based on historic data and make decisions about how to explore. The exploration/exploitation dilemma is fundamentally about long-term payoffs: is it worth trying something potentially suboptimal now in order to learn how to behave better in the future? A particularly simple and effective form of exploration is $\epsilon$ -greedy: given a function $f$ output by POLOPT, act according to $f ( x )$ with probability $( 1 - \epsilon )$ and act uniformly at random with probability . Intuitively, one would hope to improve on such a strategy by taking more (any!) information into account; for instance, basing the probability of exploration on $f$ ’s uncertainty. In this section, we describe MELˆ EE´ , first by describing how it operates at test time when applied to a new contextual bandit problem (§3.1), and then by describing how to train it using synthetic simulated contextual bandit problems $( \ S 3 . 2 )$ .
+
+# 3.1 TEST TIME BEHAVIOR OF MELˆ EE´
+
+Our goal in this paper is to learn how to explore from experience. The training procedure for MELˆ EE´ will use offline supervised learning problems to learn an exploration policy $\pi$ , which takes two inputs: a function $f \in { \mathcal { F } }$ and a context $x$ , and outputs an action. In our example, $f$ will be the output of the policy optimizer on all historic data, and $x$ will be the current user. This is used to produce an agent which interacts with the world, maintaining an initially empty history buffer $h$ , as:
+
+1. The world draws $( x _ { t } , r _ { t } ) \sim \mathcal { D }$ and reveals context $x _ { t }$ .   
+2. The agent computes $f _ { t } \gets \mathrm { P O L O P T } ( h )$ and a greedy action $\tilde { a } _ { t } = \pi ( f _ { t } , x _ { t } )$ .   
+3. The agent plays $a _ { t } = \tilde { a } _ { t }$ with probability $( 1 - \mu )$ , and $a _ { t }$ uniformly at random otherwise.   
+4. The agent observes $r _ { t } ( a _ { t } )$ and appends $( x _ { t } , a _ { t } , r _ { t } ( a _ { t } ) , p _ { t } )$ to the history $h$ , where $\begin{array} { r l } { p _ { t } } & { { } = } \end{array}$   
+$\mu / K$ if $a _ { t } \neq \tilde { a } _ { t }$ ; and $p _ { t } = 1 - \mu + \mu / K$ if $a _ { t } = \tilde { a } _ { t }$ .
+
+Here, $f _ { t }$ is the function optimized on the historical data, and $\pi$ uses it and $x _ { t }$ to choose an action. Intuitively, $\pi$ might choose to use the prediction $f _ { t } ( x _ { t } )$ most of the time, unless $f _ { t }$ is quite uncertain on this example, in which case $\pi$ might choose to return the second (or third) most likely action according to $f _ { t }$ . The agent then performs a small amount of additional $\mu$ -greedy-style exploration: most of the time it acts according to $\pi$ but occasionally it explores some more. In practice $( \ S 5 )$ , we find that setting $\mu = 0$ is optimal in aggregate, but non-zero $\mu$ is necessary for our theory $( \ S 4 )$ .
+
+Importantly, we wish to train $\pi$ using one set of tasks (for which we have fully supervised data on which to run simulations) and apply it to wholly different tasks (for which we only have bandit feedback). To achieve this, we allow $\pi$ to depend representationally on $f _ { t }$ in arbitrary ways: for instance, it might use features that capture $f _ { t }$ ’s uncertainty on the current example (see $\ S 5 . 1$ for details). We additionally allow $\pi$ to depend in a task-independent manner on the history (for instance, which actions have not yet been tried): it can use features of the actions, rewards and probabilities in the history but not depend directly on the contexts $x$ . This is to ensure that $\pi$ only learns to explore and not also to solve the underlying task-dependent classification problem. Because $\pi$ needs to learn to be task independent, we found that if $f _ { t }$ ’s predictions were uncalibrated, it was very difficult for $\pi$ to generalize well to unseen tasks. Therefore, we additionally allow $\pi$ to depend on a very small amount of fully labeled data from the task at hand, which we use to allow $\pi$ to calibrate $f _ { t }$ ’s predictions. In our experiments we use only 30 fully labeled examples, but alternative approaches to calibrating $f _ { t }$ that do not require this data would be preferable.
+
+# 3.2 TRAINING MELˆ EE BY ´ IMITATION LEARNING
+
+The meta-learning challenge is: how do we learn a good exploration policy $\pi 2$ We assume we have access to fully labeled data on which we can train $\pi$ ; this data must include context/reward pairs, but where the reward for all actions is known. This is a weak assumption: in practice, we use purely synthetic data as this training data; one could alternatively use any fully labeled classification dataset (Beygelzimer & Langford, 2009). Under this assumption about the data, it is natural to think of $\pi$ ’s behavior as a sequential decision making problem in a simulated setting, for which a natural class of learning algorithms to consider are imitation learning algorithms (Daume et al., 2009; Ross ´ et al., 2011; Ross & Bagnell, 2014; Chang et al., 2015).2
+
+Informally, at training time, MELˆ EE´ will treat one of these synthetic datasets as if it were a contextual bandit dataset. At each time step $t$ , it will compute $f _ { t }$ by running POLOPT on the historical data, and then ask: for each action, what would the long time reward look like if I were to take this action. Because the training data for MELˆ EE´ is fully labeled, this can be evaluated for each possible action, and a policy $\pi$ can be learned to maximize these rewards. More formally, in imitation learning, we assume training-time access to an expert, $\pi ^ { \star }$ , whose behavior we wish to learn to imitate at test-time. From this, we can define an optimal reference policy $\pi ^ { \star }$ , which effectively “cheats” at training time by looking at the true labels. The learning problem is then to estimate $\pi$ to have as similar behavior to $\pi ^ { \star }$ as possible, but without access to those labels.
+
+The imitation learning algorithm we use is AggreVaTe (Ross & Bagnell, 2014) (closely related to DAgger (Ross et al., 2011)), and is instantiated for the contextual bandits meta-learning problem in Alg 1. AggreVaTe learns to choose actions to minimize the cost-to-go of the expert rather than the
+
+1: for round $n = 1 , 2 , \dots , N \cdot$ do 2: initialize meta-dataset $D = \{ \}$ , choose $S$ at random from $\{ S _ { m } \}$ , and set history $h _ { 0 } = \left\{ \begin{array} { r l r } \end{array} \right\}$ 3: partition and permute $S$ randomly into train $T r$ and validation Val where $| V a l | = N _ { V a l }$ 4: for round $t = 1 , 2 , \dots , | T r |$ do 5: let $( x _ { t } , r _ { t } ) = T r _ { t }$ 6: 7: for each action optimize $\begin{array} { r } { f _ { t , a } = \mathrm { P o L O P T } ( \mathcal { F } , h _ { t - 1 } \oplus ( x _ { t } , a , r _ { t } ( a ) , 1 - \frac { K - 1 } { K } \mu ) ) } \end{array}$ $a = 1 , \ldots , K$ do on augmented history 8: roll-out: estimate $\hat { c } _ { a }$ , the cost-to-go of $a$ , using $r _ { t } ( a )$ and a roll-out policy $\pi ^ { \mathrm { { o u t } } }$ on $f _ { t , a }$ 9: end for 10: compute $f _ { t } = \mathrm { P o L O P T } ( \mathcal { F } , h _ { t - 1 } )$ 11: aggregate $D \gets D \oplus ( \Phi ( f _ { t } , x _ { t } , h _ { t - 1 } , V a l ) , \langle \hat { c } _ { 1 } , \dots , \hat { c } _ { K } \rangle )$ 12: roll-in: $\begin{array} { r } { a _ { t } \sim \frac { \mu } { K } \mathbf { 1 } _ { K } + ( 1 - \mu ) \pi _ { n - 1 } ( f _ { t } , x _ { t } ) } \end{array}$ with probability $p _ { t }$ , where 1 is the ones-vector 13: append history $h _ { t } \gets h _ { t - 1 } \oplus ( x _ { t } , a _ { t } , r _ { t } ( a _ { t } ) , p _ { t } )$ 14: end for 15: update $\pi _ { n } = \operatorname { L E A R N } ( D )$ 16: end for 17: return $\{ \pi _ { n } \} _ { n = 1 } ^ { N }$
+
+zero-one classification loss of mimicking its actions. On the first iteration AggreVaTe collects data by observing the expert perform the task, and in each trajectory, at time $t$ , explores an action $a$ in state $s$ , and observes the cost-to-go $Q$ of the expert after performing this action.
+
+Following the AggreVaTe template, MELˆ EE´ operates in an iterative fashion, starting with an arbitrary $\pi$ and improving it through interaction with an expert. Over $N$ rounds, MELˆ EE´ selects random training sets and simulates the test-time behavior on that training set. The core functionality is to generate a number of states $( f _ { t } , x _ { t } )$ on which to train $\pi$ , and to use the supervised data to estimate the value of every action from those states. MELˆ EE´ achieves this by sampling a random supervised training set and setting aside some validation data from it (line 3). It then simulates a contextual bandit problem on this training data; at each time step $t$ , it tries all actions and “pretends” like they were appended to the current history (line 7) on which it trains a new policy and evaluates it’s roll-out value (line 8). This yields, for each $t$ , a new training example for $\pi$ , which is added to $\pi$ ’s training set (line 11); the features for this example are features of the classifier based on true history (line 10) (and possibly statistics of the history itself), with a label that gives, for each action, the corresponding cost-to-go of that action (the $c _ { a } s$ computed in line 8). MELˆ EE´ then must commit to a roll-in action to actually take; it chooses this according to a roll-in policy (line 12). MELˆ EE´ has no explicit “exploitation policy”, exploitation happens when $\pi$ chooses the same action as $f _ { t }$ , while exploration happens when it chooses a different action. In learning to explore, MELˆ EE´ simultaneously learns when to exploit.
+
+Roll-in actions. The distribution over states visited by MELˆ EE´ depends on the actions taken, and in general it is good to have that distribution match what is seen at test time. This distribution is determined by a roll-in policy (line 12), controlled in MELˆ EE´ by exploration parameter $\mu \in [ 0 , 1 ]$ . As $\mu \to 1$ , the roll-in policy approaches a uniform random policy; as $\mu \to 0$ , the roll-in policy becomes deterministic. When the roll-in policy does not explore, it acts according to $\pi ( f _ { t } , . )$ .
+
+Roll-out values. The ideal value to assign to an action (from the perspective of the imitation learning procedure) is that total reward (or advantage) that would be achieved in the long run if we took this action and then behaved according to our final learned policy. Unfortunately, during training, we do not yet know the final learned policy. Thus, a surrogate roll-out policy $\pi ^ { \mathrm { { o u t } } }$ is used instead. A convenient, and often computationally efficient alternative, is to evaluate the value assuming all future actions were taken by the expert (Langford & Zadrozny, 2005; Daume et al., ´ 2009; Ross & Bagnell, 2014). In our setting, at any time step $t$ , the expert has access to the fully supervised reward vector $\mathbf { } _ { \mathbf { } } ^ { \mathbf { } } \mathbf { \Delta } \mathbf { r } _ { t }$ for the context $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ . When estimating the roll-out value for an action $a$ , the expert will return the true reward value for this action $r _ { t } ( a )$ and we use this as our estimate for the roll-out value.
+
+# 4 THEORETICAL GUARANTEES
+
+We analyze MELˆ EE´ , showing that the no-regret property of AGGREVATE can be leveraged in our meta-learning setting for learning contextual bandit exploration. In particular, we first relate the regret of the learner in line 15 to the overall regret of $\pi$ . This will show that, $i f$ the underlying classifier improves sufficiently quickly, MELˆ EE´ will achieve sublinear regret. We then show that for a specific choice of underlying classifier (BANDITRON), this is achieved. MELˆ EE´ is an instantiation of AGGREVATE (Ross & Bagnell, 2014); as such, it inherits AGGREVATE’s regret guarantees.
+
+Theorem 1 $\mathbf { T h m } 2 . 2$ of Ross $\pmb { \& }$ Bagnell (2014), adapted) After $N$ rounds, $i f$ LEARN (line 15) is no-regret algorithm, then as $N  \infty$ , with probability 1, it holds that $J ( \bar { \pi } ) ~ \leq ~ J ( \pi ^ { \star } ) +$ $2 T \sqrt { K \hat { \epsilon } _ { c l a s s } ( T ) }$ , where $J ( \cdot )$ is the reward of the exploration policy, $\bar { \pi }$ is the average policy returned, and $\hat { \epsilon } _ { c l a s s } ( T )$ is the average regression regret for each $\pi _ { n }$ accurately predicting $\hat { c } _ { i }$ , where
+
+$$
+\hat { \epsilon } _ { c l a s s } ( T ) = \operatorname* { m i n } _ { \pi \in \Pi } \frac { 1 } { N } \hat { \mathbb { E } } _ { t \sim U ( T ) , s \sim d _ { \pi _ { i } } ^ { t } } \sum _ { i = 1 } ^ { N } \Big [ Q _ { T - t + 1 } ^ { \star } ( s , \pi ) - \operatorname* { m i n } _ { a } Q _ { T - t + 1 } ^ { \star } ( s , a ) \Big ]
+$$
+
+is the empirical minimum expected cost-sensitive classification regret achieved by policies in the class $\Pi$ on all the data over the $N$ iterations of training when compared to the Bayes optimal regressor, for $U ( T )$ the uniform distribution over $\{ 1 , \ldots , T \}$ , $d _ { \pi } ^ { t }$ the distribution of states at time $t$ induced by executing policy $\pi$ , and $Q ^ { \star }$ the cost-to-go of the imitation learning expert.
+
+Thus, achieving low regret at the problem of learning $\pi$ on the training data it observes (“ $D$ ” in MELˆ EE´ ), i.e. $\hat { \epsilon } _ { c l a s s } ( T )$ is small, translates into low regret in the contextual-bandit setting. At first glance this bound looks like it may scale linearly with $T$ . However, the bound in Theorem 1 is dependent on $\hat { \epsilon } _ { c l a s s } ( T )$ . Note however, that $s$ is a combination of the context vector $x _ { t }$ and the classification function $f _ { t }$ . As $T \to \infty$ , one would hope that $f _ { t }$ improves significantly and $\hat { \epsilon } _ { c l a s s } ( T )$ decays quickly. Thus, sublinear regret may still be achievable when $f$ learns sufficiently quickly as a function of $T$ . For instance, if $f$ is optimizing a strongly convex loss function, online gradient descent achieves a regret guarantee of $O \big ( \frac { \log T } { T } \big )$ (Hazan et al., 2016, Theorem 3.3), potentially leading to a regret for MELˆ EE´ of $O ( \sqrt { ( \log T ) / T } )$ .
+
+The above statement is informal (it does not take into account the interaction between learning $f$ and $\pi$ ). However, we can show a specific concrete example: we analyze MELˆ EE´ ’s test-time behavior when the underlying learning algorithm is BANDITRON. BANDITRON is a variant of the multiclass Perceptron that operates under bandit feedback. Details of this analysis (and proofs, which directly follow the original BANDITRON analysis) are given in Appendix A; here we state the main result. Let $\gamma _ { t } = \mathrm { P r } \big [ \bar { r } _ { t } ( \pi ( f _ { t } , x _ { t } ) = 1 ) | x _ { t } | \big ] - \mathrm { P r } \big [ r _ { t } ( \bar { f } _ { t } ( x _ { t } ) ) = \hat { 1 } \big | x _ { t } \big ]$ be the edge of $\pi ( f _ { t } , . )$ over $f$ , and $\begin{array} { r } { \Gamma = \frac { 1 } { T } \sum _ { t = 1 } ^ { T } \mathbb { E } \frac { 1 } { 1 + K \gamma _ { t } } } \end{array}$ be an overall measure of the edge. For instance if $\pi$ simply returns $f$ ’s prediction, then all $\gamma _ { t } = 0$ and $\Gamma = 1$ . We can then show the following:
+
+Theorem 2 Assume that for the sequence of examples, $( x _ { 1 } , pmb { r } _ { 1 } ) , ( x _ { 2 } , \pmb { r } _ { 2 } ) , \dots , ( x _ { T } , \pmb { r } _ { T } )$ , we have, for all $t _ { : }$ , $| | x _ { t } | | \leq 1$ . Let $W ^ { \star }$ be any matrix, let $L$ be the cumulative hinge-loss of $W ^ { \star }$ , let $\mu$ be a uniform exploration probability, and let $D = 2 \left| \left| W ^ { \star } \right| \right| _ { F } ^ { 2 }$ be the complexity of $W ^ { \star }$ . Assume that $\mathbb { E } \gamma _ { t } \geq 0$ for all $t$ . Then the number of mistakes $M$ made by MELˆ EE´ with BANDITRON as POLOPT satisfies:
+
+$$
+\mathbb { E } M \leq L + K \mu T + 3 \operatorname* { m a x } \left\{ D \Gamma / \mu , \sqrt { D T K \Gamma \mu } \right\} + \sqrt { D L \Gamma / \mu }
+$$
+
+where the expectation is taken with respect to the randomness of the algorithm.
+
+Note that under the assumption $\mathbb { E } \gamma _ { t } \geq 0$ for all $t$ , we have $\Gamma \leq 1$ . The analysis gives the same mistake bound for BANDITRON but with the factor of $\Gamma$ , hence this result improves upon the BANDITRON analysis only when $\Gamma < 1$ (in the realizable setting, the number of mistakes is analogous to the regret). This result is highly stylized and the assumption that $\mathbb { E } \gamma _ { t } \geq 0$ is overly strong. This assumption ensures that $\pi$ never decreases the probability of a “correct” action. It does, however, help us understand the behavior of MELˆ EE´ , qualitatively: First, the quantity that matters in Theorem 2, $\mathbb { E } _ { t } { \gamma } _ { t }$ is (in the $_ { 0 / 1 }$ loss case) exactly what MELˆ EE´ is optimizing: the expected improvement for choosing an action against $f _ { t }$ ’s recommendation. Second, the benefit of using $\pi$ within BANDITRON is a local benefit: because $\pi$ is trained with expert rollouts, as discussed in $\ S 4$ , the primary improvement in the analysis is to ensure that $\pi$ does a better job predicting (in a single step) than $f _ { t }$ does. An obvious open question is whether it is possible to base the analysis on the regret of $\pi$ (rather than its error) and whether it is possible to extend beyond the BANDITRON.
+
+# 5 EXPERIMENTAL SETUP AND RESULTS
+
+Using a collection of synthetically generated classification problems, we train an exploration policy $\pi$ using MELˆ EE´ (Alg 1). This exploration policy learns to explore on the basis of calibrated probabilistic predictions from $f$ together with a predefined set of exploration features $( \ S 5 . 1 )$ . Once $\pi$ is learned and fixed, we follow the test-time behavior described in $\ S 3 . 1$ to evaluate $\pi$ on a set of contextual bandit problems. We evaluate MELˆ EE´ on a natural learning to rank task $( \ S 5 . 3 . 1 )$ . To ensure that the performance of MELˆ EE´ generalizes beyond this single learning to rank task, we additionally perform thorough evaluation on 300 “simulated” contextual bandit problems, derived from standard classification tasks (§5.3.2).
+
+In all cases, the underlying classifier $f$ is a linear model trained with a policy optimizer that runs stochastic gradient descent (details are in $\ S \mathbf { A } . 2 )$ . We seek to answer two questions experimentally: (1) How does MELˆ EE´ compare empirically to alternative (expert designed) exploration strategies? (2) How important are the additional features used by MELˆ EE´ in comparison to using calibrated probability predictions from $f$ as features?
+
+# 5.1 TRAINING DETAILS FOR THE EXPLORATION POLICY
+
+Exploration Features. In our experiments, the exploration policy is trained based on features $\Phi$ (Alg 1, line 11). These features are allowed to depend on the current classifier $f _ { t }$ , and on any part of the history except the inputs $x _ { t }$ in order to maintain task independence. We additionally ensure that its features are independent of the dimensionality of the inputs, so that $\pi$ can generalize to datasets of arbitrary dimensions. The specific features we use are listed below; these are largely inspired by Konyushkova et al. (2017) but adapted and augmented to our setting.
+
+The features of $f _ { t }$ that we use are: a) predicted probability $p ( a _ { t } | f _ { t } , \pmb { x } _ { t } )$ , we use a softmax over the predicted rewards from $f _ { t }$ to convert them to probabilities; b) entropy of the predicted probability distribution; c) a one-hot encoding for the predicted action $f _ { t } ( \pmb { x } _ { t } )$ . The features of $h _ { t - 1 }$ that we use are: a) current time step $t ; { \bf b } )$ normalized counts for all previous actions predicted so far; c) average observed rewards for each action; d) empirical variance of the observed rewards for each action in the history. In our experiments, we found that it is essential to calibrate the predicted probabilities of the classifier $f _ { t }$ . We use a very small held-out dataset, of size 30, to achieve this. We use Platt’s scaling (Platt, 1999; Lin et al., 2007) method to calibrate the predicted probabilities. Platt’s scaling works by fitting a logistic regression model to the classifier’s predicted scores.
+
+Training Datasets. In our experiments, we follow Konyushkova et al. (2017) (and also Peters et al. (2014), in a different setting) and train the exploration policy $\pi$ only on synthetic data. This is possible because the exploration policy $\pi$ never makes use of $x$ explicitly and instead only accesses it via $f _ { t }$ ’s behavior on it. We generate datasets with uniformly distributed class conditional distributions. The datasets are always two-dimensional. Details are in $\ S \mathrm { A } . 1$ .
+
+# 5.2 EVALUATION METHODOLOGY
+
+For evaluation, we use progressive validation (Blum et al., 1999), which is exactly computing the reward of the algorithm. Specifically, to evaluate the performance of an exploration algorithm $\mathcal { A }$ on a dataset $S$ of size $n$ , we compute the progressive validation return $\begin{array} { r } { G ( \mathcal { A } ) = \frac { 1 } { n } \sum _ { t = 1 } ^ { n } r _ { t } ( a _ { t } ) } \end{array}$ as the average reward up to $n$ , where $a _ { t }$ is the action chosen by the algorithm $\mathcal { A }$ and $r _ { t }$ is the true reward.
+
+Because our evaluation is over 300 datasets, we report aggregate results in two forms. The simpler one is Win/Loss Statistics: We compare two exploration methods on a given dataset by counting the number of statistically significant wins and losses. An exploration algorithm $\mathcal { A }$ wins over another algorithm $\boldsymbol { B }$ if the progressive validation return $G ( { \mathcal { A } } )$ is statistically significantly larger than $B$ ’s return $G ( B )$ at the 0.01 level using a paired sample t-test. We also report cumulative distributions of rewards for each algorithm, following Zhang et al. (2019). In particular, for a given relative reward value $( x \in [ 0 , 1 ] )$ , the corresponding CDF value for a given algorithm is the fraction of datasets on which this algorithm achieved reward at least $x$ . We compute relative reward by Min
+
+Max normalization: linearly transforming reward $y$ to $\begin{array} { r } { y ^ { \prime } = \frac { y - \mathrm { m i n } } { \mathrm { m a x - m i n } } } \end{array}$ , where min & max are the minimum & maximum rewards among all exploration algorithms.
+
+In our experiments, we compare to the following baseline exploration methods, keeping the policy optimization method fixed (details in $\ S \mathbf { A . 4 } )$ ): $\epsilon$ -greedy (Sutton, 1996); $\epsilon$ -decreasing (Sutton & Barto, 1998); EG $\epsilon$ -greedy (Li et al., 2010b); $\tau$ -first. We additionally compare to three state-of-the-art exploration methods: LinUCB (Li et al., 2010a); Cover (Agarwal et al., 2014); and its variant Cover-NU (Bietti et al., 2018). We select the best hyperparameters following Bietti et al. (2018).
+
+# 5.3 EXPERIMENTAL RESULTS
+
+# 5.3.1 LEARNING TO RANK
+
+We evaluate MELˆ EE´ on a natural learning to rank dataset. The dataset we consider is the Microsoft Learning to Rank dataset, variant MSLR-10K from Qin & Liu (2013) 3. The dataset consists of feature vectors extracted from query-url pairs along with relevance judgment labels. The relevance judgments are obtained from a retired labeling set of a commercial web search engine (Microsoft Bing), which take 5 values from 0 (irrelevant) to 4 (perfectly relevant) and we drop the queries not labelled as any of the two extremes. In our experiments, we limit the number of labels to the two extremes: 0 and 4. A query-url pair is represented by a 136-dimensional feature vector. The dataset is highly imbalanced as the number of irrelevant queries is much larger than the number of relevant ones. To address this, we sample the number of irrelevant queries to match that of the relevant ones. To avoid correlations between the observed query-url pairs, we group the queries by the query ID, and sample a single query from each group. We convert relevance scores to losses with 0 indicating a perfectly relevant document, and 1 an irrelevant one.
+
+Figure 1 shows the evaluation results on a subset of the MSLR-10K dataset. Since the performance is closely matched between the different exploration algorithms, we repeat the experiment 16 times with randomly shuffled permutations of the MSLR-10K dataset. Figure 1 (left) shows the learning curve of the trained policy $\pi$ as well as the baselines. Here, we see that MELˆ EE´ quickly achieves high reward, after about 100 examples the two strongest baselines catch up. By 200 examples all approaches have asymptoted. We exclude LinUCB from these runs because the required matrix inversions made it too computationally expensive.4 Figure 1 shows statistically-significant win/loss differences for each of the algorithms, across these 16 shuffles. Each row/column entry shows the number of times the row algorithm won against the column, minus the number of losses. MELˆ EE´ is the only algorithm that always wins more than it loses against other algorithms, and outperforms the nearest competition ( $\epsilon$ -decreasing) by 3 points.
+
+# 5.3.2 SIMULATED CONTEXTUAL BANDIT TASKS
+
+We additionally perform an exhaustive evaluation on simulated contextual bandit tasks to ensure that the performance of MELˆ EE´ generalizes beyond learning to rank. Following Bietti et al. (2018), we use a collection of 300 binary classification datasets from openml.org for evaluation; the precise list and download instructions is in $\ S \mathbf { A } . 3$ . These datasets cover a variety of different domains including text $\&$ image processing, medical, and sensory data. We convert classification datasets into cost-sensitive classification problems by using a $0 / 1$ encoding. Given these fully supervised cost-sensitive multi-class datasets, we simulate the contextual bandit setting by only revealing the reward for the selected actions.
+
+In Figure 2 (left), we show a representative learning curve. Here, we see that as more data becomes available, all the approaches improve (except $\tau$ -first, which has ceased to learn after $2 \%$ of the data). MELˆ EE´ , in particular, is able to very quickly achieve near-optimal performance (in around 40 examples) in comparison to the best baseline which takes at least 200. In Figure 2 (right), we show the CDFs for the different algorithms. To help read this, at $x = 1 . 0$ , MELˆ EE´ has a relative reward at least 1.0 on more than $40 \%$ of datasets, while $\epsilon$ -decreasing and $\epsilon$ -greedy achieve this on about $30 \%$ of datasets. We find that the two strongest baselines are $\epsilon$ -decreasing and $\epsilon$ -greedy (better when reward differences are small, toward the left of the graph). The two curves for $\epsilon$ -decreasing and $\epsilon$ - greedy coincide. This happens because the exploration probability $\epsilon _ { 0 }$ for $\epsilon$ -decreasing decays rapidly approaching zero with a rate of $\textstyle { \frac { 1 } { t } }$ , where $t$ is the index of the current round. MELˆ EE´ outperforms the baselines in the “large reward” regimes (right of graph) but under-performs $\epsilon$ -decreasing and $\epsilon$ -greedy in low reward regimes (left of graph).
+
+![](images/b1788988d738da0efcd31535810491c3b39d1eba306ed5431107fee49afac2b5.jpg)  
+Figure 1: Results for the Learning to Rank task. (Left) Learning curve on the MSLR-10K dataset: $\mathbf { X }$ -axis shows the number of queries observed, and y-axis shows the progressive reward. (Right) Win/Loss counts for all pairs of algorithms over 16 random shuffles for the MSLR-10K dataset.
+
+![](images/6888bb6073c77103de6a8010443f100180a1163ae34fbd197c0760f993ad28e5.jpg)  
+Figure 2: Behavior of MELˆ EE´ in comparison to baseline and state-of-the-art exploration algorithms.
+
+In Figure 3, we show statistically-significant win/loss differences for each of the algorithms. Here, each (row, column) entry shows the number of times the row algorithm won against the column, minus the number of losses. MELˆ EE´ is the only algorithm that always wins more than it loses against other algorithms, and outperforms the nearest competition ( $\epsilon$ -decreasing) by 23 points.
+
+To understand more directly how MELˆ EE´ compares to $\epsilon$ -decreasing, in the left plot of Figure 4, we show a scatter plot of rewards achieved by MELˆ EE´ $\mathbf { \dot { X } }$ -axis) and $\epsilon$ -decreasing (y-axis) on each of the 300 datasets, with statistically significant differences highlighted in red and insignificant differences in blue. Points below the diagonal line correspond to better performance by MELˆ EE´ (147 datasets)
+
+![](images/2e5f7991d2955d71f4a06f822d4d7174981f8622bdddcce1efae21f30ba0af0b.jpg)  
+Figure 3: Win/Loss counts for all pairs of algorithms (columns match the rows).
+
+![](images/f000364f695f671698bcf02790d820913e704e54048dceca345b44fcdbac3291.jpg)  
+Figure 4: Scatterplots comparing MELˆ EE´ to the best baseline and to a variant with fewer features.
+
+and points above to $\epsilon$ -decreasing (124 datasets). The remaining 29 had no statistically significant difference.
+
+Finally, we consider the effect that the additional features have on MELˆ EE´ ’s performance. In particular, we consider a version of MELˆ EE´ with all features (this is the version used in all other experiments) with an ablated version that only has access to the (calibrated) probabilities of each action from the underlying classifier $f$ . The comparison is shown as a scatter plot in Figure 4 (right). Here, we can see that the full feature set does provide lift over just the calibrated probabilities, with a win-minus-loss improvement of 24 by adding additional features from which to learn to explore.
+
+# 6 RELATED WORK AND DISCUSSION
+
+The field of meta-learning is based on the idea of replacing hand-engineered learning heuristics with heuristics learned from data. One of the most relevant settings for meta-learning to ours is active learning, in which one aims to learn a decision function to decide which examples, from a pool of unlabeled examples, should be labeled. Past approaches to meta-learning for active learning include reinforcement learning-based strategies (Woodward & Finn, 2017; Fang et al., 2017), imitation learning-based strategies (Bachman et al., 2017), and batch supervised learning-based strategies (Konyushkova et al., 2017). Similar approaches have been used to learn heuristics for optimization (Li & Malik, 2016; Andrychowicz et al., 2016), multiarm (non-contextual) bandits Maes et al. (2012), and neural architecture search (Zoph & Le, 2016), recently mostly based on (deep) reinforcement learning. While meta-learning for contextual bandits is most similar to meta-learning for active learning, there is a fundamental difference that makes it significantly more challenging: in active learning, the goal is to select as few examples as you can to learn, so by definition the horizon is short; in contextual bandits, learning to explore is fundamentally a long-horizon problem, because what matters is not immediate reward but long term learning.
+
+In reinforcement learning, Gupta et al. (2018) investigated the task of meta-learning an exploration strategy for a distribution of related tasks by learning a latent exploration space. Similarly, Xu et al. (2018) proposed a teacher-student approach for learning to do exploration in off-policy reinforcement learning. While these approaches are effective if the distribution of tasks is very similar and the state space is shared among different tasks, they fail to generalize when the tasks are different. Our approach targets an easier problem than exploration in full reinforcement learning environments, and can generalize well across a wide range of different tasks with completely unrelated features spaces.
+
+There has also been a substantial amount of work on constructing “good” exploration policies, in problems of varying complexity: traditional bandit settings (Karnin & Anava, 2016), contextual bandits (Fraud et al., 2016) and reinforcement learning (Osband et al., 2016). In both bandit settings, most of this work has focused on the learning theory aspect of exploration: what exploration distributions guarantee that learning will succeed (with high probability)? MELˆ EE´ , lacks such guarantees: in particular, if the data distribution of the observed contexts $( \phi ( f _ { t } ) )$ in some test problem differs substantially from that on which MELˆ EE´ was trained, we can say nothing about the quality of the learned exploration. Nevertheless, despite fairly substantial distribution mismatch (synthetic real-world), MELˆ EE´ works well in practice, and our stylized theory $( \ S 4 )$ suggests that there may be an interesting avenue for developing strong theoretical results for contextual bandit learning with learned exploration policies, and perhaps other meta-learning problems.
+
+In conclusion, we presented MELˆ EE´ , a meta-learning algorithm for learning exploration policies in the contextual bandit setting. MELˆ EE´ enjoys no-regret guarantees, and empirically it outperforms alternative exploration algorithm in most settings. One limitation of MELˆ EE´ is the computational resources required during the offline training phase on the synthetic datasets. In the future, we will work on improving the computational efficiency for MELˆ EE´ in the offline training phase and scale the experimental analysis to problems with larger number of classes.
+
+# REFERENCES
+
+Alekh Agarwal, Daniel Hsu, Satyen Kale, John Langford, Lihong Li, and Robert E. Schapire. Taming the monster: A fast and simple algorithm for contextual bandits. In In Proceedings of the 31st International Conference on Machine Learning (ICML-14, pp. 1638–1646, 2014.   
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, pp. 3981–3989, 2016.   
+Peter Auer. Using confidence bounds for exploitation-exploration trade-offs. The Journal of Machine Learning Research, 3:397–422, 2003.   
+Philip Bachman, Alessandro Sordoni, and Adam Trischler. Learning algorithms for active learning. In ICML, 2017.   
+Alina Beygelzimer and John Langford. The offset tree for learning with partial labels. In Proceedings of the 15th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 129–138. ACM, 2009.   
+Alberto Bietti, Alekh Agarwal, and John Langford. A Contextual Bandit Bake-off. working paper or preprint, May 2018.   
+Avrim Blum, Adam Kalai, and John Langford. Beating the hold-out: Bounds for k-fold and progressive cross-validation. In Proceedings of the twelfth annual conference on Computational learning theory, pp. 203–208. ACM, 1999.   
+Leo Breiman. Random forests. Mach. Learn., 45(1):5–32, October 2001. ISSN 0885-6125. doi: 10.1023/A:1010933404324.
+
+Kai-Wei Chang, Akshay Krishnamurthy, Alekh Agarwal, Hal Daume, III, and John Langford. ´ Learning to search better than your teacher. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML, pp. 2058–2066. JMLR.org, 2015.
+
+Hal Daume, III, John Langford, and Daniel Marcu. Search-based structured prediction. ´ Machine Learning, 75(3):297–325, Jun 2009. ISSN 1573-0565. doi: 10.1007/s10994-009-5106-x.
+
+Miroslav Dudik, Daniel Hsu, Satyen Kale, Nikos Karampatziakis, John Langford, Lev Reyzin, and Tong Zhang. Efficient optimal learning for contextual bandits. arXiv preprint arXiv:1106.2369, 2011.
+
+Meng Fang, Yuan Li, and Trevor Cohn. Learning how to active learn: A deep reinforcement learning approach. In EMNLP, 2017.
+
+Raphal Fraud, Robin Allesiardo, Tanguy Urvoy, and Fabrice Clrot. Random forest for the contextual bandit problem. In Arthur Gretton and Christian C. Robert (eds.), Proceedings of the 19th International Conference on Artificial Intelligence and Statistics, volume 51 of Proceedings of Machine Learning Research, pp. 93–101, Cadiz, Spain, 09–11 May 2016. PMLR.
+
+Abhishek Gupta, Russell Mendonca, YuXuan Liu, Pieter Abbeel, and Sergey Levine. Metareinforcement learning of structured exploration strategies. arXiv preprint arXiv:1802.07245, 2018.
+
+Elad Hazan et al. Introduction to online convex optimization. Foundations and Trends $\textsuperscript { \textregistered }$ in Optimization, 2(3-4):157–325, 2016.
+
+Leslie Pack Kaelbling. Associative reinforcement learning: Functions ink-dnf. Machine Learning, 15(3):279–298, 1994.
+
+Sham M. Kakade, Shai Shalev-Shwart, and Ambuj Tewari. Efficient bandit algorithms for online multiclass prediction. In ICML, 2008.
+
+Zohar S Karnin and Oren Anava. Multi-armed bandits: Competing with optimal sequences. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 199–207. Curran Associates, Inc., 2016.
+
+Ksenia Konyushkova, Raphael Sznitman, and Pascal Fua. Learning active learning from data. In Advances in Neural Information Processing Systems, 2017.
+
+John Langford and Bianca Zadrozny. Relating reinforcement learning performance to classification performance. In Proceedings of the 22nd international conference on Machine learning, pp. 473–480. ACM, 2005.
+
+John Langford and Tong Zhang. The epoch-greedy algorithm for multi-armed bandits with side information. In Advances in Neural Information Processing Systems 20, pp. 817–824. Curran Associates, Inc., 2008.
+
+Ke Li and Jitendra Malik. Learning to optimize. arXiv preprint arXiv:1606.01885, 2016.
+
+Lihong Li, Wei Chu, John Langford, and Robert E. Schapire. A contextual-bandit approach to personalized news article recommendation. In Proceedings of the 19th International Conference on World Wide Web, WWW ’10, pp. 661–670, New York, NY, USA, 2010a. ACM. ISBN 978-1- 60558-799-8. doi: 10.1145/1772690.1772758.
+
+Wei Li, Xuerui Wang, Ruofei Zhang, Ying Cui, Jianchang Mao, and Rong Jin. Exploitation and exploration in a performance based contextual advertising system. In Proceedings of the 16th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’10, pp. 27–36, New York, NY, USA, 2010b. ACM.
+
+Hsuan-Tien Lin, Chih-Jen Lin, and Ruby C. Weng. A note on platt’s probabilistic outputs for support vector machines. Machine Learning, 68(3):267–276, Oct 2007. ISSN 1573-0565. doi: 10.1007/s10994-007-5018-6.
+
+Francis Maes, Louis Wehenkel, and Damien Ernst. Meta-learning of exploration/exploitation strategies: The multi-armed bandit case. In International Conference on Agents and Artificial Intelligence, pp. 100–115. Springer, 2012.
+
+Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped dqn. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4026–4034. Curran Associates, Inc., 2016.
+
+F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011.
+
+Jonas Peters, Joris M Mooij, Dominik Janzing, and Bernhard Scholkopf. Causal discovery with ¨ continuous additive noise models. The Journal of Machine Learning Research, 15(1):2009–2053, 2014.
+
+John C. Platt. Probabilistic outputs for support vector machines and comparisons to regularized likelihood methods. In ADVANCES IN LARGE MARGIN CLASSIFIERS, pp. 61–74. MIT Press, 1999.
+
+Tao Qin and Tie-Yan Liu. Introducing LETOR 4.0 datasets. CoRR, abs/1306.2597, 2013. URL http://arxiv.org/abs/1306.2597.
+
+Stephane Ross and J Andrew Bagnell. Reinforcement and imitation learning via interactive no-regret ´ learning. arXiv preprint arXiv:1406.5979, 2014.
+
+Stephane Ross, Geoffrey Gordon, and J Andrew Bagnell. A reduction of imitation learning and ´ structured prediction to no-regret online learning. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, volume 15 of Proceedings of Machine Learning Research, pp. 627–635, Fort Lauderdale, FL, USA, 11–13 Apr 2011. PMLR.
+
+Richard S Sutton. Generalization in reinforcement learning: Successful examples using sparse coarse coding. In Advances in neural information processing systems, pp. 1038–1044, 1996.
+
+Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981.
+
+Mark Woodward and Chelsea Finn. Active one-shot learning. arXiv preprint arXiv:1702.06559, 2017.
+
+Tianbing Xu, Qiang Liu, Liang Zhao, Wei Xu, and Jian Peng. Learning to explore with meta-policy gradient. arXiv preprint arXiv:1803.05044, 2018.
+
+Chicheng Zhang, Alekh Agarwal, Hal Daume, III, John Langford, and Sahand N Negahban. Warm- ´ starting contextual bandits: Robustly combining supervised and bandit feedback. In ICML, 2019.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+# Supplementary Material For: Learning Effective Exploration Strategies for Contextual Bandits
+
+A STYLIZED TEST-TIME ANALYSIS FOR BANDITRON: DETAILS
+
+The BANDITRONMELˆ EE´ algorithm is specified in $\mathrm { A l g } 2$ . The is exactly the same as the typical test time behavior, except it uses a BANDITRON-type strategy for learning the underlying classifier $f$ in the place of POLOPT. POLICYELIMINATIONMETA takes as arguments: $\pi$ (the learned exploration policy) and $\mu \in ( 0 , 1 / ( 2 K ) )$ an added uniform exploration parameter. The BANDITRON learns a linear multi-class classifier parameterized by a weight matrix of size $K { \times } D$ , where $D$ is the input dimensionality. The BANDITRON assumes a pure multi-class setting in which the reward for one (“correct”) action is 1 and the reward for all other actions is zero.
+
+At each round $t$ , a prediction $\hat { a } _ { t }$ is made according to $f _ { t }$ (summarized by $W ^ { t }$ ). We then define an exploration distribution that “most of the time” acts according to $\pi ( f _ { t } , . )$ , but smooths each action with $\mu$ probability. The chosen action $a _ { t }$ is sampled from this distribution and a binary reward is observed. The weights of the BANDITRON are updated according to the BANDITRON update rule using $\tilde { U } ^ { t }$ .
+
+# Algorithm 2 BANDITRONMELˆ EE´ $( g , \mu )$
+
+1: initialize $W ^ { 1 } = \mathbf { 0 } \in \mathbb { R } ^ { K \times D }$   
+2: for rounds $t = 1 \dots T$ : do   
+3: observe $\boldsymbol { x } _ { t } \in \mathbb { R } ^ { D }$   
+4: compute $\begin{array} { r } { \hat { a } _ { t } = f _ { t } ( x _ { t } ) = \mathrm { a r g m a x } _ { k \in K } \left( W ^ { t } x _ { t } \right) _ { k } } \end{array}$   
+5: define $Q ^ { \mu } ( a ) = \mu + ( 1 - K \mu ) { \bf 1 } [ a = \pi ( W ^ { t } , x _ { t } ) ]$   
+6: sample $a _ { t } \sim Q ^ { \mu }$   
+7: observe reward $r _ { t } ( a _ { t } ) \in \{ 0 , 1 \}$   
+8: d $\tilde { U } ^ { t } \in \mathbb { R } ^ { K \times D }$   
+$\begin{array} { r } { \tilde { U } _ { a , \cdot } ^ { t } = x _ { t } \left( \frac { \mathbf { 1 } [ r _ { t } ( a _ { t } ) = 1 ] \mathbf { 1 } [ a _ { t } = a ] } { Q ^ { \mu } ( a ) } - \mathbf { 1 } [ \hat { a } _ { t } = a ] \right) } \end{array}$   
+9: update $W ^ { t + 1 } = W ^ { t } + \tilde { U } ^ { t }$
+
+The only difference between BANDITRONMELˆ EE´ and the original BANDITRON is the introduction of $\pi$ in the sampling distribution. The original algorithm achieves the following mistake bound shown below, which depends on the notion of multi-class hinge-loss. In particular, the hinge-loss of $W$ on $( x , r )$ is $\ell ( W , ( x , \pmb { r } ) ) = \mathrm { m a x } _ { a \neq a ^ { \star } }$ max $\left\{ 0 , 1 - ( W x ) _ { a ^ { \star } } + ( W x ) _ { a } ^ { \top } \right\}$ , where $a ^ { \star }$ is the $a$ for which $r ( a ) = 1$ . The overall hinge-loss $L$ is the sum of $\ell$ over the sequence of examples.
+
+Theorem 3 (Thm. 1 and Corr. 2 of Kakade et al. (2008)) Assume that for the sequence of examples, $( x _ { 1 } , r _ { 1 } ) , ( x _ { 2 } , r _ { 2 } ) , \ldots , ( x _ { T } , \pmb { r } _ { T } )$ , we have, for all $t _ { : }$ , $| | x _ { t } | | \leq 1$ . Let $W ^ { \star }$ be any matrix, let $L$ be the cumulative hinge-loss of $W ^ { \star }$ , and let $D = 2 \left| \left| W ^ { \star } \right| \right| _ { F } ^ { 2 }$ be the complexity of $W ^ { \star }$ . The number of mistakes $M$ made by the BANDITRON satisfies
+
+$$
+{ \mathbb { E } } M \leq L + K \mu T + 3 \operatorname* { m a x } \left\{ { \frac { D } { \mu } } , { \sqrt { D T K \mu } } \right\} + { \sqrt { D L / \mu } }
+$$
+
+where the expectation is taken with respect to the randomness of the algorithm. Furthermore, in a low noise setting (there exists $W ^ { \star }$ with fixed complexity √ $d$ and loss $\bar { L ( \mathbf { \Omega } \leq \cal { O } ( \sqrt { \cal { D } K T } ) ) }$ , then by setting $\mu = \sqrt { D / ( T K ) }$ , we obtain $\mathbb { E } M \le O ( \sqrt { K D T } )$ .
+
+We can prove an analogous result for BANDITRONMELˆ EE´ . The key quantity that will control how much $\pi$ improves the execution of BANDITRONMELˆ EE´ is how much $\pi$ improves on $f _ { t }$ when $f _ { t }$ is $\pi ( f _ { t } , . )$ In p over $f$ ticul, and $\begin{array} { r } { \Gamma = \frac { 1 } { T } \sum _ { t = 1 } ^ { T } \mathbb { E } \frac { 1 } { 1 + K \gamma _ { t } } } \end{array}$ $\gamma _ { t } = \operatorname* { P r } [ r _ { t } ( \pi ( f _ { t } , x _ { t } ) = 1 ) | x _ { t } ] - \operatorname* { P r } [ r _ { t } ( f _ { t } ( x _ { t } ) ) = 1 | x _ { t } ]$ $\pi$ e the edge ofdoes nothing, then all $\gamma _ { t } = 0$ $\Gamma = 1 .$ .) Given this quantity, we can prove the following Theorem 2.
+
+Proof: [sketch] The proof is a small modification of the original proof of Theorem 3. The only change is that in the original proof, the following bound is used: $\mathbb { E } _ { t } | | \bar { \tilde { U } } ^ { t } | | ^ { 2 } / | | x _ { t } | | ^ { 2 } = 1 + 1 / \mu \le 2 / \mu$
+
+We use, instead: Et||U˜ t||2/||xt||2 ≤ 1 + Et 1µ+γt 2Et 11+γtµ . The rest of the proof goes through identically.
+
+# A.1 DETAILS OF SYNTHETIC DATASETS
+
+We generate datasets with uniformly distributed class conditional distributions. We generate 2D datasets by first sampling a random variable representing the Bayes classification error. The Bayes error is sampled uniformly from the interval 0.0 to 0.5. Next, we generate a balanced dataset where the data for each class lies within a unit rectangle and sampled uniformly. We overlap the sampling rectangular regions to generate a dataset with the desired Bayes error selected in the first step.
+
+# A.2 IMPLEMENTATION DETAILS
+
+Our implementation is based on scikit-learn (Pedregosa et al., 2011). We fix the training time exploration parameter $\mu$ to 0.1. We train the exploration policy $\pi$ on 82 synthetic datasets each of size 3000 with uniform class conditional distributions, a total of $2 4 6 k$ samples (§A.1). We train $\pi$ using a linear classifier Breiman (2001) and set the hyper-parameters for the learning rate, and data scaling methods using three-fold cross-validation on the whole meta-training dataset. For the classifier class $\mathcal { F }$ , we use a linear model trained with stochastic gradient descent. We standardize all features to zero mean and unit variance, or scale the features to lie between zero and one. To select between the two scaling methods, and tune the classifier’s learning rate, we use three-fold cross-validation on a small fully supervised training set of size 30 samples. The same set is used to calibrate the predicted probabilities of $f _ { t }$ .
+
+# A.3 LIST OF DATASETS
+
+The datasets we used can be accessed at https://www.openml.org/d/<id>. The list of (id, size) pairs below shows the (id for the datasets we used and the dataset size in number of examples:
+
+(46,100) (716, 100) (726, 100) (754, 100) (762, 100) (768, 100) (775, 100) (783, 100) (789, 100) (808, 100) (812, 100) (828, 100) (829, 100) (850, 100) (865, 100) (868, 100) (875, 100) (876, 100) (878, 100) (916, 100) (922, 100) (932, 100) (1473, 100) (965, 101) (1064, 101) (956, 106) (1061, 107) (771, 108) (736, 111) (448, 120) (782, 120) (1455, 120) (1059, 121) (1441, 123) (714, 125) (867, 130) (924, 130) (1075, 130) (1141, 130) (885, 131) (444, 132) (921, 132) (974, 132) (719, 137) (1013, 138) (1151, 138) (784, 140) (1045, 145) (1066, 145) (1125, 146) (902, 147) (1006, 148) (969, 150) (955, 151) (1026, 155) (745, 159) (756, 159) (1085, 159) (1054, 161) (748, 163) (747, 167) (973, 178) (463, 180) (801, 185) (1164, 185) (788, 186) (1154, 187) (941, 189) (1131, 193) (753, 194) (1012, 194) (1155, 195) (1488, 195) (446, 200) (721, 200) (1124, 201) (1132, 203) (40, 208) (733, 209) (796, 209) (996, 214) (1005, 214) (895, 222) (1412, 226) (820, 235) (851, 240) (464, 250) (730, 250) (732, 250) (744, 250) (746, 250) (763, 250) (769, 250) (773, 250) (776, 250) (793, 250) (794, 250) (830, 250) (832, 250) (834, 250) (863, 250) (873, 250) (877, 250) (911, 250) (918, 250) (933, 250) (935, 250) (1136, 250) (778, 252) (1442, 253) (1449, 253) (1159, 259) (450, 264) (811, 264) (336, 267) (1152, 267) (53, 270) (1073, 274) (1156, 275) (880, 284) (1121, 294) (43, 306) (818, 310) (915, 315) (1157, 321) (1162, 322) (925, 323) (1140, 324) (1144, 329) (1011, 336) (1147, 337) (1133, 347) (337, 349) (59, 351) (1135, 355) (1143, 363) (1048, 369) (860, 380) (1129, 384) (1163, 386) (900, 400) (906, 400) (907, 400) (908, 400) (909, 400) (1025, 400) (1071, 403) (1123, 405) (1160, 410) (1126, 412) (1122, 413) (1127, 421) (764, 450) (1065, 458) (1149, 458) (1498, 462) (724, 468) (814, 468) (1148, 468) (1150, 470) (765, 475) (767, 475) (1153, 484) (742, 500) (749, 500) (750, 500) (766, 500) (779, 500) (792, 500) (805, 500) (824, 500) (838, 500) (855, 500) (869, 500) (870, 500) (879, 500) (884, 500) (886, 500) (888, 500) (896, 500) (920, 500) (926, 500) (936, 500) (937, 500) (943, 500) (987, 500) (1470, 500) (825, 506) (853, 506) (872, 506) (717, 508) (1063, 522) (954, 531) (1467, 540) (1165, 542) (1137, 546) (335, 554) (333, 556) (947, 559) (949, 559) (950, 559) (951, 559) (826, 576) (1004, 600) (334, 601) (1158, 604) (770, 625) (997, 625) (1145, 630) (1443, 661) (774, 662) (795, 662) (827, 662) (931, 662) (292, 690) (1451, 705) (1464, 748) (37, 768) (1014, 797) (970, 841) (994, 846) (841, 950) (50, 958) (1016, 990) (31, 1000) (715, 1000) (718, 1000) (723, 1000) (740, 1000) (743, 1000) (751, 1000) (797, 1000) (799, 1000) (806, 1000) (813, 1000) (837, 1000) (845, 1000) (849, 1000) (866, 1000) (903, 1000) (904, 1000) (910, 1000) (912, 1000) (913, 1000) (917, 1000) (741, 1024) (1444, 1043) (1453, 1077)
+
+(1068, 1109) (934, 1156) (1049, 1458) (1454, 1458) (983, 1473) (1128, 1545) (1130, 1545) (1138, 1545) (1139, 1545) (1142, 1545) (1146, 1545) (1161, 1545) (1166, 1545) (1050, 1563) (991, 1728) (962, 2000) (971, 2000) (978, 2000) (995, 2000) (1020, 2000) (1022, 2000) (914, 2001) (1067, 2109) (772, 2178) (948, 2178) (958, 2310) (312, 2407) (1487, 2534) (737, 3107) (953, 3190) (3, 3196) (1038, 3468) (871, 3848) (728, 4052) (720, 4177) (1043, 4562) (44, 4601) (979, 5000) (1460, 5300) (1489, 5404) (1021, 5473) (1069, 5589) (980, 5620) (847, 6574) (1116, 6598) (803, 7129) (1496, 7400) (725, 8192) (735, 8192) (752, 8192) (761, 8192) (807, 8192)
+
+# A.4 BASELINE EXPLORATION ALGORITHMS
+
+Our experiments aim to determine how MELˆ EE´ compares to other standard exploration strategies. In particular, we compare to:
+
+$\epsilon$ -greedy: With probability $\epsilon$ , explore uniformly at random; with probability $1 - \epsilon$ act greedily according to $f _ { t }$ (Sutton, 1996). Experimentally, we found $\epsilon = 0$ optimal on average, consistent with the results of Bietti et al. (2018).
+
+$\epsilon$ -decreasing: selects a random action with probabilities $\epsilon _ { i }$ , where $\epsilon _ { i } = \epsilon _ { 0 } / t , \epsilon _ { 0 } \in ] 0 , 1 ]$ and $t$ is the index of the current round. In our experiments we set $\epsilon _ { 0 } = 0 . 1$ . (Sutton & Barto, 1998)
+
+Exponentiated Gradient $\epsilon$ -greedy: maintains a set of candidate values for $\epsilon$ -greedy exploration. At each iteration, it runs a sampling procedure to select a new $\epsilon$ from a finite set of candidates. The probabilities associated with the candidates are initialized uniformly and updated with the Exponentiated Gradient (EG) algorithm. Following Li et al. (2010b), we use the candidate set $\{ \epsilon _ { i } = 0 . 0 5 { \times } i + 0 . 0 1 , i = 1 , \cdot \cdot \cdot , 1 0 \}$ for $\epsilon$ .
+
+LinUCB: Maintains confidence bounds for reward payoffs and selects actions with the highest confidence bound. It is impractical to run “as is” due to high-dimensional matrix inversions. We use diagonal approximation to the covariance when the dimensions exceeds 150. (Li et al., 2010a) $\tau$ -first: Explore uniformly on the first $\tau$ fraction of the data; after that, act greedily.
+
+Cover: Maintains a uniform distribution over a fixed number of policies. The policies are used to approximate a covering distribution over policies that are good for both exploration and exploitation (Agarwal et al., 2014).
+
+Cover Non-Uniform: similar to Cover, but reduces the level of exploration of Cover to be more competitive with the Greedy method. Cover-Nu doesn’t add extra exploration beyond the actions chose by the covering policies (Bietti et al., 2018).
+
+In all cases, we select the best hyperparameters for each exploration algorithm following Bietti et al. (2018). These hyperparameters are: the choice of $\epsilon$ in $\epsilon$ -greedy, $\tau$ in $\tau$ -first, the number of bags, and the tolerance $\psi$ for Cover and Cover-NU. We set $\epsilon = 0 . 0$ , $\tau = 0 . 0 2$ , bag size $= 1 6$ , and $\psi = 0 . 1$ .

parse/train/Bkgk624KDB/Bkgk624KDB_content_list.json

@@ -0,0 +1,1610 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING EFFECTIVE EXPLORATION STRATEGIES FOR CONTEXTUAL BANDITS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            782,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contextual bandits, an algorithm must choose actions given observed contexts, learning from a reward signal that is observed only for the action chosen. This leads to an exploration/exploitation trade-off: the algorithm must balance taking actions it already believes are good with taking new actions to potentially discover better choices. We develop a meta-learning algorithm, MELˆ EE´ , that learns an exploration policy based on simulated, synthetic contextual bandit tasks. MELˆ EE´ uses imitation learning against these simulations to train an exploration policy that can be applied to true contextual bandit tasks at test time. We evaluate on both a natural contextual bandit problem derived from a learning to rank dataset as well as hundreds of simulated contextual bandit problems derived from classification tasks. MELˆ EE´ outperforms seven strong baselines on most of these datasets by leveraging a rich feature representation for learning an exploration strategy. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            434
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            463,
+            336,
+            479
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In a contextual bandit problem, an agent attempts to optimize its behavior over a sequence of rounds based on limited feedback (Kaelbling, 1994; Auer, 2003; Langford & Zhang, 2008). In each round, the agent chooses an action based on a context (features) for that round, and observes a reward for that action but no others $( \\ S 2 )$ . Contextual bandit problems arise in many real-world settings like online recommendations and personalized medicine. As in reinforcement learning, the agent must learn to balance exploitation (taking actions that, based on past experience, it believes will lead to high instantaneous reward) and exploration (trying actions that it knows less about). ",
+        "bbox": [
+            174,
+            496,
+            825,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a meta-learning approach to automatically learn a good exploration mechanism from data. To achieve this, we use synthetic supervised learning data sets on which we can simulate contextual bandit tasks in an offline setting. Based on these simulations, our algorithm, MELˆ EE´ (MEta LEarner for Exploration)1, learns a good heuristic exploration strategy that should ideally generalize to future contextual bandit problems. MELˆ EE´ contrasts with more classical approaches to exploration (like $\\epsilon$ -greedy or LinUCB; see $\\ S 6$ ), in which exploration strategies are constructed by expert algorithm designers. These approaches often achieve provably good exploration strategies in the worst case, but are potentially overly pessimistic and are sometimes computationally intractable. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            724
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "At training time (§ 3.2), MELˆ EE´ simulates many contextual bandit problems from fully labeled synthetic data. Using this data, in each round, MELˆ EE´ is able to counterfactually simulate what would happen under all possible action choices. We can then use this information to compute regret estimates for each action, which can be optimized using the AggreVaTe imitation learning algorithm (Ross & Bagnell, 2014). Our imitation learning strategy mirrors that of the meta-learning approach of Bachman et al. (2017) in the active learning setting. We present a simplified, stylized analysis of the behavior of MELˆ EE´ to ensure that our cost function encourages good behavior $( \\ S 4 )$ . Empirically, we use MELˆ EE´ to train an exploration policy on only synthetic datasets and evaluate this policy on both a contextual bandit task based on a natural learning to rank dataset as well as three hundred simulated contextual bandit tasks (§5.2). We compare the trained policy to a number of alternative exploration algorithms, and show the efficacy of our approach (§5.3). ",
+        "bbox": [
+            174,
+            731,
+            825,
+            885
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES: CONTEXTUAL BANDITS AND POLICY OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            102,
+            789,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contextual bandits is a model of interaction in which an agent chooses actions (based on contexts) and receives immediate rewards for that action alone. For example, in a simplified news personalization setting, at each time step $t$ , a user arrives and the system must choose a news article to display to them. Each possible news article corresponds to an action $a$ , and the user corresponds to a context $x _ { t }$ . After the system chooses an article $a _ { t }$ to display, it can observe, for instance, the amount of time that the user spends reading that article, which it can use as a reward $r _ { t } ( a _ { t } )$ . ",
+        "bbox": [
+            173,
+            146,
+            825,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Formally, we largely follow the setup and notation of Agarwal et al. (2014). Let $\\mathcal { X }$ be an input space of contexts (users) and $[ K ] = \\bar { \\{ 1 , \\dots , K \\} }$ be a finite action space (articles). We consider the statistical setting in which there exists a fixed but unknown distribution $\\mathcal { D }$ over pairs $( x , r ) \\in$ $\\mathcal { X } \\times [ 0 , 1 ] ^ { K }$ , where $\\pmb { r }$ is a vector of rewards (for convenience, we assume all rewards are bounded in $[ 0 , 1 ] )$ . In this setting, the world operates iteratively over rounds $t = 1 , 2 , \\ldots .$ Each round $t$ : ",
+        "bbox": [
+            174,
+            237,
+            823,
+            308
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. The world draws $( x _ { t } , r _ { t } ) \\sim \\mathcal { D }$ and reveals context $x _ { t }$ .   \n2. The agent (randomly) chooses action $a _ { t } \\in [ K ]$ based on $x _ { t }$ , and observes reward $r _ { t } ( a _ { t } )$ . ",
+        "bbox": [
+            204,
+            315,
+            808,
+            344
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal of an algorithm is to maximize the cumulative sum of rewards over time. Typically the primary quantity considered is the average regret of a sequence of actions $a _ { 1 } , \\dots , a _ { T }$ to the behavior of the best possible function in a prespecified class $\\mathcal { F }$ : ",
+        "bbox": [
+            174,
+            351,
+            820,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66da3a800878c29c71b0f53e3c28a794e467e3310406c2ec81b78ad68d7c7147.jpg",
+        "text": "$$\n\\lambda ( a _ { 1 } , \\ldots , a _ { T } ) = \\operatorname* { m a x } _ { f \\in { \\mathcal { F } } } { \\frac { 1 } { T } } \\sum _ { t = 1 } ^ { T } \\left[ r _ { t } ( f ( x _ { t } ) ) - r _ { t } ( a _ { t } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            392,
+            666,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An agent is call no-regret if its average regret is zero in the limit of large $T$ ",
+        "bbox": [
+            178,
+            433,
+            666,
+            446
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To produce a good agent for interacting with the world, we assume access to a function class $\\mathcal { F }$ and to an oracle policy optimizer for that function class. For example, $\\mathcal { F }$ may be a set of single layer neural networks mapping user features $x \\in \\mathcal { X }$ to predicted rewards for actions $a \\in [ K ]$ . Formally, the observable record of interaction resulting from round $t$ is the tuple $( x _ { t } , a _ { t } , r _ { t } ( \\bar { a } _ { t } ) , p _ { t } ( a _ { t } ) ) \\ \\in$ $\\mathcal { X } { \\times } [ K ] { \\times } [ 0 , 1 ] { \\times } [ 0 , 1 ]$ , where $p _ { t } ( a _ { t } )$ is the probability that the agent chose action $a _ { t }$ , and the full history of interaction is $h _ { t } = \\langle ( x _ { i } , a _ { i } , r _ { i } ( a _ { i } ) , p _ { i } ( a _ { i } ) ) \\rangle _ { i = 1 } ^ { t }$ . The oracle policy optimizer, POLOPT, takes as input a history of user interactions and outputs an $f \\in { \\mathcal { F } }$ with low expected regret. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            551
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A standard example of a policy optimizer is to combine inverse propensity scaling (IPS) with a regression algorithm (Dudik et al., 2011). Here, given a history $h$ , each tuple $( x , a , r , p )$ in that history is mapped to a multiple-output regression example. The input for this regression example is the same $x$ ; the output is a vector of $K$ costs, all of which are zero except the $a ^ { \\mathrm { { t h } } }$ component, which takes value $r / p$ . This mapping is done for all tuples in the history, and a supervised learning algorithm on the function class $\\mathcal { F }$ is used to produce a low-regret regressor $f$ . This is the function returned by the policy optimizer. IPS, and other estimators that have lower-variance than IPS (such as the doubly-robust estimator), have the property of being unbiased. In experiments, we use the direct method (Dudik et al., 2011) largely for its simplicity, however, MELˆ EE´ is agnostic to the type of the estimator used by the policy optimizer. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            696
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH: LEARNING AND EFFECTIVE EXPLORATION STRATEGY",
+        "text_level": 1,
+        "bbox": [
+            173,
+            739,
+            758,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to have an effective approach to the contextual bandit problem, one must be able to both optimize a policy based on historic data and make decisions about how to explore. The exploration/exploitation dilemma is fundamentally about long-term payoffs: is it worth trying something potentially suboptimal now in order to learn how to behave better in the future? A particularly simple and effective form of exploration is $\\epsilon$ -greedy: given a function $f$ output by POLOPT, act according to $f ( x )$ with probability $( 1 - \\epsilon )$ and act uniformly at random with probability \u000f. Intuitively, one would hope to improve on such a strategy by taking more (any!) information into account; for instance, basing the probability of exploration on $f$ ’s uncertainty. In this section, we describe MELˆ EE´ , first by describing how it operates at test time when applied to a new contextual bandit problem (§3.1), and then by describing how to train it using synthetic simulated contextual bandit problems $( \\ S 3 . 2 )$ . ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 TEST TIME BEHAVIOR OF MELˆ EE´ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            447,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal in this paper is to learn how to explore from experience. The training procedure for MELˆ EE´ will use offline supervised learning problems to learn an exploration policy $\\pi$ , which takes two inputs: a function $f \\in { \\mathcal { F } }$ and a context $x$ , and outputs an action. In our example, $f$ will be the output of the policy optimizer on all historic data, and $x$ will be the current user. This is used to produce an agent which interacts with the world, maintaining an initially empty history buffer $h$ , as: ",
+        "bbox": [
+            176,
+            128,
+            825,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. The world draws $( x _ { t } , r _ { t } ) \\sim \\mathcal { D }$ and reveals context $x _ { t }$ .   \n2. The agent computes $f _ { t } \\gets \\mathrm { P O L O P T } ( h )$ and a greedy action $\\tilde { a } _ { t } = \\pi ( f _ { t } , x _ { t } )$ .   \n3. The agent plays $a _ { t } = \\tilde { a } _ { t }$ with probability $( 1 - \\mu )$ , and $a _ { t }$ uniformly at random otherwise.   \n4. The agent observes $r _ { t } ( a _ { t } )$ and appends $( x _ { t } , a _ { t } , r _ { t } ( a _ { t } ) , p _ { t } )$ to the history $h$ , where $\\begin{array} { r l } { p _ { t } } & { { } = } \\end{array}$   \n$\\mu / K$ if $a _ { t } \\neq \\tilde { a } _ { t }$ ; and $p _ { t } = 1 - \\mu + \\mu / K$ if $a _ { t } = \\tilde { a } _ { t }$ . ",
+        "bbox": [
+            210,
+            207,
+            823,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $f _ { t }$ is the function optimized on the historical data, and $\\pi$ uses it and $x _ { t }$ to choose an action. Intuitively, $\\pi$ might choose to use the prediction $f _ { t } ( x _ { t } )$ most of the time, unless $f _ { t }$ is quite uncertain on this example, in which case $\\pi$ might choose to return the second (or third) most likely action according to $f _ { t }$ . The agent then performs a small amount of additional $\\mu$ -greedy-style exploration: most of the time it acts according to $\\pi$ but occasionally it explores some more. In practice $( \\ S 5 )$ , we find that setting $\\mu = 0$ is optimal in aggregate, but non-zero $\\mu$ is necessary for our theory $( \\ S 4 )$ . ",
+        "bbox": [
+            174,
+            284,
+            825,
+            367
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Importantly, we wish to train $\\pi$ using one set of tasks (for which we have fully supervised data on which to run simulations) and apply it to wholly different tasks (for which we only have bandit feedback). To achieve this, we allow $\\pi$ to depend representationally on $f _ { t }$ in arbitrary ways: for instance, it might use features that capture $f _ { t }$ ’s uncertainty on the current example (see $\\ S 5 . 1$ for details). We additionally allow $\\pi$ to depend in a task-independent manner on the history (for instance, which actions have not yet been tried): it can use features of the actions, rewards and probabilities in the history but not depend directly on the contexts $x$ . This is to ensure that $\\pi$ only learns to explore and not also to solve the underlying task-dependent classification problem. Because $\\pi$ needs to learn to be task independent, we found that if $f _ { t }$ ’s predictions were uncalibrated, it was very difficult for $\\pi$ to generalize well to unseen tasks. Therefore, we additionally allow $\\pi$ to depend on a very small amount of fully labeled data from the task at hand, which we use to allow $\\pi$ to calibrate $f _ { t }$ ’s predictions. In our experiments we use only 30 fully labeled examples, but alternative approaches to calibrating $f _ { t }$ that do not require this data would be preferable. ",
+        "bbox": [
+            173,
+            373,
+            825,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING MELˆ EE BY ´ IMITATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            522,
+            584
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The meta-learning challenge is: how do we learn a good exploration policy $\\pi 2$ We assume we have access to fully labeled data on which we can train $\\pi$ ; this data must include context/reward pairs, but where the reward for all actions is known. This is a weak assumption: in practice, we use purely synthetic data as this training data; one could alternatively use any fully labeled classification dataset (Beygelzimer & Langford, 2009). Under this assumption about the data, it is natural to think of $\\pi$ ’s behavior as a sequential decision making problem in a simulated setting, for which a natural class of learning algorithms to consider are imitation learning algorithms (Daume et al., 2009; Ross ´ et al., 2011; Ross & Bagnell, 2014; Chang et al., 2015).2 ",
+        "bbox": [
+            174,
+            595,
+            825,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Informally, at training time, MELˆ EE´ will treat one of these synthetic datasets as if it were a contextual bandit dataset. At each time step $t$ , it will compute $f _ { t }$ by running POLOPT on the historical data, and then ask: for each action, what would the long time reward look like if I were to take this action. Because the training data for MELˆ EE´ is fully labeled, this can be evaluated for each possible action, and a policy $\\pi$ can be learned to maximize these rewards. More formally, in imitation learning, we assume training-time access to an expert, $\\pi ^ { \\star }$ , whose behavior we wish to learn to imitate at test-time. From this, we can define an optimal reference policy $\\pi ^ { \\star }$ , which effectively “cheats” at training time by looking at the true labels. The learning problem is then to estimate $\\pi$ to have as similar behavior to $\\pi ^ { \\star }$ as possible, but without access to those labels. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The imitation learning algorithm we use is AggreVaTe (Ross & Bagnell, 2014) (closely related to DAgger (Ross et al., 2011)), and is instantiated for the contextual bandits meta-learning problem in Alg 1. AggreVaTe learns to choose actions to minimize the cost-to-go of the expert rather than the ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: for round $n = 1 , 2 , \\dots , N \\cdot$ do 2: initialize meta-dataset $D = \\{ \\}$ , choose $S$ at random from $\\{ S _ { m } \\}$ , and set history $h _ { 0 } = \\left\\{ \\begin{array} { r l r } \\end{array} \\right\\}$ 3: partition and permute $S$ randomly into train $T r$ and validation Val where $| V a l | = N _ { V a l }$ 4: for round $t = 1 , 2 , \\dots , | T r |$ do 5: let $( x _ { t } , r _ { t } ) = T r _ { t }$ 6: 7: for each action optimize $\\begin{array} { r } { f _ { t , a } = \\mathrm { P o L O P T } ( \\mathcal { F } , h _ { t - 1 } \\oplus ( x _ { t } , a , r _ { t } ( a ) , 1 - \\frac { K - 1 } { K } \\mu ) ) } \\end{array}$ $a = 1 , \\ldots , K$ do on augmented history 8: roll-out: estimate $\\hat { c } _ { a }$ , the cost-to-go of $a$ , using $r _ { t } ( a )$ and a roll-out policy $\\pi ^ { \\mathrm { { o u t } } }$ on $f _ { t , a }$ 9: end for 10: compute $f _ { t } = \\mathrm { P o L O P T } ( \\mathcal { F } , h _ { t - 1 } )$ 11: aggregate $D \\gets D \\oplus ( \\Phi ( f _ { t } , x _ { t } , h _ { t - 1 } , V a l ) , \\langle \\hat { c } _ { 1 } , \\dots , \\hat { c } _ { K } \\rangle )$ 12: roll-in: $\\begin{array} { r } { a _ { t } \\sim \\frac { \\mu } { K } \\mathbf { 1 } _ { K } + ( 1 - \\mu ) \\pi _ { n - 1 } ( f _ { t } , x _ { t } ) } \\end{array}$ with probability $p _ { t }$ , where 1 is the ones-vector 13: append history $h _ { t } \\gets h _ { t - 1 } \\oplus ( x _ { t } , a _ { t } , r _ { t } ( a _ { t } ) , p _ { t } )$ 14: end for 15: update $\\pi _ { n } = \\operatorname { L E A R N } ( D )$ 16: end for 17: return $\\{ \\pi _ { n } \\} _ { n = 1 } ^ { N }$ ",
+        "bbox": [
+            176,
+            136,
+            820,
+            377
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "zero-one classification loss of mimicking its actions. On the first iteration AggreVaTe collects data by observing the expert perform the task, and in each trajectory, at time $t$ , explores an action $a$ in state $s$ , and observes the cost-to-go $Q$ of the expert after performing this action. ",
+        "bbox": [
+            176,
+            429,
+            821,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following the AggreVaTe template, MELˆ EE´ operates in an iterative fashion, starting with an arbitrary $\\pi$ and improving it through interaction with an expert. Over $N$ rounds, MELˆ EE´ selects random training sets and simulates the test-time behavior on that training set. The core functionality is to generate a number of states $( f _ { t } , x _ { t } )$ on which to train $\\pi$ , and to use the supervised data to estimate the value of every action from those states. MELˆ EE´ achieves this by sampling a random supervised training set and setting aside some validation data from it (line 3). It then simulates a contextual bandit problem on this training data; at each time step $t$ , it tries all actions and “pretends” like they were appended to the current history (line 7) on which it trains a new policy and evaluates it’s roll-out value (line 8). This yields, for each $t$ , a new training example for $\\pi$ , which is added to $\\pi$ ’s training set (line 11); the features for this example are features of the classifier based on true history (line 10) (and possibly statistics of the history itself), with a label that gives, for each action, the corresponding cost-to-go of that action (the $c _ { a } s$ computed in line 8). MELˆ EE´ then must commit to a roll-in action to actually take; it chooses this according to a roll-in policy (line 12). MELˆ EE´ has no explicit “exploitation policy”, exploitation happens when $\\pi$ chooses the same action as $f _ { t }$ , while exploration happens when it chooses a different action. In learning to explore, MELˆ EE´ simultaneously learns when to exploit. ",
+        "bbox": [
+            173,
+            479,
+            825,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Roll-in actions. The distribution over states visited by MELˆ EE´ depends on the actions taken, and in general it is good to have that distribution match what is seen at test time. This distribution is determined by a roll-in policy (line 12), controlled in MELˆ EE´ by exploration parameter $\\mu \\in [ 0 , 1 ]$ . As $\\mu \\to 1$ , the roll-in policy approaches a uniform random policy; as $\\mu \\to 0$ , the roll-in policy becomes deterministic. When the roll-in policy does not explore, it acts according to $\\pi ( f _ { t } , . )$ . ",
+        "bbox": [
+            174,
+            708,
+            823,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Roll-out values. The ideal value to assign to an action (from the perspective of the imitation learning procedure) is that total reward (or advantage) that would be achieved in the long run if we took this action and then behaved according to our final learned policy. Unfortunately, during training, we do not yet know the final learned policy. Thus, a surrogate roll-out policy $\\pi ^ { \\mathrm { { o u t } } }$ is used instead. A convenient, and often computationally efficient alternative, is to evaluate the value assuming all future actions were taken by the expert (Langford & Zadrozny, 2005; Daume et al., ´ 2009; Ross & Bagnell, 2014). In our setting, at any time step $t$ , the expert has access to the fully supervised reward vector $\\mathbf { } _ { \\mathbf { } } ^ { \\mathbf { } } \\mathbf { \\Delta } \\mathbf { r } _ { t }$ for the context $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { t } }$ . When estimating the roll-out value for an action $a$ , the expert will return the true reward value for this action $r _ { t } ( a )$ and we use this as our estimate for the roll-out value. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 THEORETICAL GUARANTEES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            447,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We analyze MELˆ EE´ , showing that the no-regret property of AGGREVATE can be leveraged in our meta-learning setting for learning contextual bandit exploration. In particular, we first relate the regret of the learner in line 15 to the overall regret of $\\pi$ . This will show that, $i f$ the underlying classifier improves sufficiently quickly, MELˆ EE´ will achieve sublinear regret. We then show that for a specific choice of underlying classifier (BANDITRON), this is achieved. MELˆ EE´ is an instantiation of AGGREVATE (Ross & Bagnell, 2014); as such, it inherits AGGREVATE’s regret guarantees. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            218
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 $\\mathbf { T h m } 2 . 2$ of Ross $\\pmb { \\& }$ Bagnell (2014), adapted) After $N$ rounds, $i f$ LEARN (line 15) is no-regret algorithm, then as $N  \\infty$ , with probability 1, it holds that $J ( \\bar { \\pi } ) ~ \\leq ~ J ( \\pi ^ { \\star } ) +$ $2 T \\sqrt { K \\hat { \\epsilon } _ { c l a s s } ( T ) }$ , where $J ( \\cdot )$ is the reward of the exploration policy, $\\bar { \\pi }$ is the average policy returned, and $\\hat { \\epsilon } _ { c l a s s } ( T )$ is the average regression regret for each $\\pi _ { n }$ accurately predicting $\\hat { c } _ { i }$ , where ",
+        "bbox": [
+            173,
+            229,
+            825,
+            289
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fc57316187212e37a37f2d715a05aa99428209ef03223db0cc28ff5d7e71957.jpg",
+        "text": "$$\n\\hat { \\epsilon } _ { c l a s s } ( T ) = \\operatorname* { m i n } _ { \\pi \\in \\Pi } \\frac { 1 } { N } \\hat { \\mathbb { E } } _ { t \\sim U ( T ) , s \\sim d _ { \\pi _ { i } } ^ { t } } \\sum _ { i = 1 } ^ { N } \\Big [ Q _ { T - t + 1 } ^ { \\star } ( s , \\pi ) - \\operatorname* { m i n } _ { a } Q _ { T - t + 1 } ^ { \\star } ( s , a ) \\Big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            287,
+            750,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "is the empirical minimum expected cost-sensitive classification regret achieved by policies in the class $\\Pi$ on all the data over the $N$ iterations of training when compared to the Bayes optimal regressor, for $U ( T )$ the uniform distribution over $\\{ 1 , \\ldots , T \\}$ , $d _ { \\pi } ^ { t }$ the distribution of states at time $t$ induced by executing policy $\\pi$ , and $Q ^ { \\star }$ the cost-to-go of the imitation learning expert. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, achieving low regret at the problem of learning $\\pi$ on the training data it observes (“ $D$ ” in MELˆ EE´ ), i.e. $\\hat { \\epsilon } _ { c l a s s } ( T )$ is small, translates into low regret in the contextual-bandit setting. At first glance this bound looks like it may scale linearly with $T$ . However, the bound in Theorem 1 is dependent on $\\hat { \\epsilon } _ { c l a s s } ( T )$ . Note however, that $s$ is a combination of the context vector $x _ { t }$ and the classification function $f _ { t }$ . As $T \\to \\infty$ , one would hope that $f _ { t }$ improves significantly and $\\hat { \\epsilon } _ { c l a s s } ( T )$ decays quickly. Thus, sublinear regret may still be achievable when $f$ learns sufficiently quickly as a function of $T$ . For instance, if $f$ is optimizing a strongly convex loss function, online gradient descent achieves a regret guarantee of $O \\big ( \\frac { \\log T } { T } \\big )$ (Hazan et al., 2016, Theorem 3.3), potentially leading to a regret for MELˆ EE´ of $O ( \\sqrt { ( \\log T ) / T } )$ . ",
+        "bbox": [
+            173,
+            395,
+            825,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above statement is informal (it does not take into account the interaction between learning $f$ and $\\pi$ ). However, we can show a specific concrete example: we analyze MELˆ EE´ ’s test-time behavior when the underlying learning algorithm is BANDITRON. BANDITRON is a variant of the multiclass Perceptron that operates under bandit feedback. Details of this analysis (and proofs, which directly follow the original BANDITRON analysis) are given in Appendix A; here we state the main result. Let $\\gamma _ { t } = \\mathrm { P r } \\big [ \\bar { r } _ { t } ( \\pi ( f _ { t } , x _ { t } ) = 1 ) | x _ { t } | \\big ] - \\mathrm { P r } \\big [ r _ { t } ( \\bar { f } _ { t } ( x _ { t } ) ) = \\hat { 1 } \\big | x _ { t } \\big ]$ be the edge of $\\pi ( f _ { t } , . )$ over $f$ , and $\\begin{array} { r } { \\Gamma = \\frac { 1 } { T } \\sum _ { t = 1 } ^ { T } \\mathbb { E } \\frac { 1 } { 1 + K \\gamma _ { t } } } \\end{array}$ be an overall measure of the edge. For instance if $\\pi$ simply returns $f$ ’s prediction, then all $\\gamma _ { t } = 0$ and $\\Gamma = 1$ . We can then show the following: ",
+        "bbox": [
+            173,
+            532,
+            825,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 Assume that for the sequence of examples, $( x _ { 1 } , pmb { r } _ { 1 } ) , ( x _ { 2 } , \\pmb { r } _ { 2 } ) , \\dots , ( x _ { T } , \\pmb { r } _ { T } )$ , we have, for all $t _ { : }$ , $| | x _ { t } | | \\leq 1$ . Let $W ^ { \\star }$ be any matrix, let $L$ be the cumulative hinge-loss of $W ^ { \\star }$ , let $\\mu$ be a uniform exploration probability, and let $D = 2 \\left| \\left| W ^ { \\star } \\right| \\right| _ { F } ^ { 2 }$ be the complexity of $W ^ { \\star }$ . Assume that $\\mathbb { E } \\gamma _ { t } \\geq 0$ for all $t$ . Then the number of mistakes $M$ made by MELˆ EE´ with BANDITRON as POLOPT satisfies: ",
+        "bbox": [
+            173,
+            662,
+            823,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8907c9db3773df0101946376dcd5d4f4bcf8c6149f1c09495336d9aeb23e98e1.jpg",
+        "text": "$$\n\\mathbb { E } M \\leq L + K \\mu T + 3 \\operatorname* { m a x } \\left\\{ D \\Gamma / \\mu , \\sqrt { D T K \\Gamma \\mu } \\right\\} + \\sqrt { D L \\Gamma / \\mu }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            733,
+            712,
+            760
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is taken with respect to the randomness of the algorithm. ",
+        "bbox": [
+            176,
+            758,
+            689,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that under the assumption $\\mathbb { E } \\gamma _ { t } \\geq 0$ for all $t$ , we have $\\Gamma \\leq 1$ . The analysis gives the same mistake bound for BANDITRON but with the factor of $\\Gamma$ , hence this result improves upon the BANDITRON analysis only when $\\Gamma < 1$ (in the realizable setting, the number of mistakes is analogous to the regret). This result is highly stylized and the assumption that $\\mathbb { E } \\gamma _ { t } \\geq 0$ is overly strong. This assumption ensures that $\\pi$ never decreases the probability of a “correct” action. It does, however, help us understand the behavior of MELˆ EE´ , qualitatively: First, the quantity that matters in Theorem 2, $\\mathbb { E } _ { t } { \\gamma } _ { t }$ is (in the $_ { 0 / 1 }$ loss case) exactly what MELˆ EE´ is optimizing: the expected improvement for choosing an action against $f _ { t }$ ’s recommendation. Second, the benefit of using $\\pi$ within BANDITRON is a local benefit: because $\\pi$ is trained with expert rollouts, as discussed in $\\ S 4$ , the primary improvement in the analysis is to ensure that $\\pi$ does a better job predicting (in a single step) than $f _ { t }$ does. An obvious open question is whether it is possible to base the analysis on the regret of $\\pi$ (rather than its error) and whether it is possible to extend beyond the BANDITRON. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL SETUP AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            521,
+            167
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using a collection of synthetically generated classification problems, we train an exploration policy $\\pi$ using MELˆ EE´ (Alg 1). This exploration policy learns to explore on the basis of calibrated probabilistic predictions from $f$ together with a predefined set of exploration features $( \\ S 5 . 1 )$ . Once $\\pi$ is learned and fixed, we follow the test-time behavior described in $\\ S 3 . 1$ to evaluate $\\pi$ on a set of contextual bandit problems. We evaluate MELˆ EE´ on a natural learning to rank task $( \\ S 5 . 3 . 1 )$ . To ensure that the performance of MELˆ EE´ generalizes beyond this single learning to rank task, we additionally perform thorough evaluation on 300 “simulated” contextual bandit problems, derived from standard classification tasks (§5.3.2). ",
+        "bbox": [
+            174,
+            183,
+            823,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In all cases, the underlying classifier $f$ is a linear model trained with a policy optimizer that runs stochastic gradient descent (details are in $\\ S \\mathbf { A } . 2 )$ . We seek to answer two questions experimentally: (1) How does MELˆ EE´ compare empirically to alternative (expert designed) exploration strategies? (2) How important are the additional features used by MELˆ EE´ in comparison to using calibrated probability predictions from $f$ as features? ",
+        "bbox": [
+            171,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 TRAINING DETAILS FOR THE EXPLORATION POLICY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            388,
+            576,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Exploration Features. In our experiments, the exploration policy is trained based on features $\\Phi$ (Alg 1, line 11). These features are allowed to depend on the current classifier $f _ { t }$ , and on any part of the history except the inputs $x _ { t }$ in order to maintain task independence. We additionally ensure that its features are independent of the dimensionality of the inputs, so that $\\pi$ can generalize to datasets of arbitrary dimensions. The specific features we use are listed below; these are largely inspired by Konyushkova et al. (2017) but adapted and augmented to our setting. ",
+        "bbox": [
+            173,
+            414,
+            825,
+            498
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The features of $f _ { t }$ that we use are: a) predicted probability $p ( a _ { t } | f _ { t } , \\pmb { x } _ { t } )$ , we use a softmax over the predicted rewards from $f _ { t }$ to convert them to probabilities; b) entropy of the predicted probability distribution; c) a one-hot encoding for the predicted action $f _ { t } ( \\pmb { x } _ { t } )$ . The features of $h _ { t - 1 }$ that we use are: a) current time step $t ; { \\bf b } )$ normalized counts for all previous actions predicted so far; c) average observed rewards for each action; d) empirical variance of the observed rewards for each action in the history. In our experiments, we found that it is essential to calibrate the predicted probabilities of the classifier $f _ { t }$ . We use a very small held-out dataset, of size 30, to achieve this. We use Platt’s scaling (Platt, 1999; Lin et al., 2007) method to calibrate the predicted probabilities. Platt’s scaling works by fitting a logistic regression model to the classifier’s predicted scores. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            630
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training Datasets. In our experiments, we follow Konyushkova et al. (2017) (and also Peters et al. (2014), in a different setting) and train the exploration policy $\\pi$ only on synthetic data. This is possible because the exploration policy $\\pi$ never makes use of $x$ explicitly and instead only accesses it via $f _ { t }$ ’s behavior on it. We generate datasets with uniformly distributed class conditional distributions. The datasets are always two-dimensional. Details are in $\\ S \\mathrm { A } . 1$ . ",
+        "bbox": [
+            174,
+            637,
+            823,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 EVALUATION METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            421,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For evaluation, we use progressive validation (Blum et al., 1999), which is exactly computing the reward of the algorithm. Specifically, to evaluate the performance of an exploration algorithm $\\mathcal { A }$ on a dataset $S$ of size $n$ , we compute the progressive validation return $\\begin{array} { r } { G ( \\mathcal { A } ) = \\frac { 1 } { n } \\sum _ { t = 1 } ^ { n } r _ { t } ( a _ { t } ) } \\end{array}$ as the average reward up to $n$ , where $a _ { t }$ is the action chosen by the algorithm $\\mathcal { A }$ and $r _ { t }$ is the true reward. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            805
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Because our evaluation is over 300 datasets, we report aggregate results in two forms. The simpler one is Win/Loss Statistics: We compare two exploration methods on a given dataset by counting the number of statistically significant wins and losses. An exploration algorithm $\\mathcal { A }$ wins over another algorithm $\\boldsymbol { B }$ if the progressive validation return $G ( { \\mathcal { A } } )$ is statistically significantly larger than $B$ ’s return $G ( B )$ at the 0.01 level using a paired sample t-test. We also report cumulative distributions of rewards for each algorithm, following Zhang et al. (2019). In particular, for a given relative reward value $( x \\in [ 0 , 1 ] )$ , the corresponding CDF value for a given algorithm is the fraction of datasets on which this algorithm achieved reward at least $x$ . We compute relative reward by Min",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Max normalization: linearly transforming reward $y$ to $\\begin{array} { r } { y ^ { \\prime } = \\frac { y - \\mathrm { m i n } } { \\mathrm { m a x - m i n } } } \\end{array}$ , where min & max are the minimum & maximum rewards among all exploration algorithms. ",
+        "bbox": [
+            173,
+            102,
+            823,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we compare to the following baseline exploration methods, keeping the policy optimization method fixed (details in $\\ S \\mathbf { A . 4 } )$ ): $\\epsilon$ -greedy (Sutton, 1996); $\\epsilon$ -decreasing (Sutton & Barto, 1998); EG $\\epsilon$ -greedy (Li et al., 2010b); $\\tau$ -first. We additionally compare to three state-of-the-art exploration methods: LinUCB (Li et al., 2010a); Cover (Agarwal et al., 2014); and its variant Cover-NU (Bietti et al., 2018). We select the best hyperparameters following Bietti et al. (2018). ",
+        "bbox": [
+            174,
+            140,
+            825,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            227,
+            392,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3.1 LEARNING TO RANK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            252,
+            372,
+            267
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate MELˆ EE´ on a natural learning to rank dataset. The dataset we consider is the Microsoft Learning to Rank dataset, variant MSLR-10K from Qin & Liu (2013) 3. The dataset consists of feature vectors extracted from query-url pairs along with relevance judgment labels. The relevance judgments are obtained from a retired labeling set of a commercial web search engine (Microsoft Bing), which take 5 values from 0 (irrelevant) to 4 (perfectly relevant) and we drop the queries not labelled as any of the two extremes. In our experiments, we limit the number of labels to the two extremes: 0 and 4. A query-url pair is represented by a 136-dimensional feature vector. The dataset is highly imbalanced as the number of irrelevant queries is much larger than the number of relevant ones. To address this, we sample the number of irrelevant queries to match that of the relevant ones. To avoid correlations between the observed query-url pairs, we group the queries by the query ID, and sample a single query from each group. We convert relevance scores to losses with 0 indicating a perfectly relevant document, and 1 an irrelevant one. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows the evaluation results on a subset of the MSLR-10K dataset. Since the performance is closely matched between the different exploration algorithms, we repeat the experiment 16 times with randomly shuffled permutations of the MSLR-10K dataset. Figure 1 (left) shows the learning curve of the trained policy $\\pi$ as well as the baselines. Here, we see that MELˆ EE´ quickly achieves high reward, after about 100 examples the two strongest baselines catch up. By 200 examples all approaches have asymptoted. We exclude LinUCB from these runs because the required matrix inversions made it too computationally expensive.4 Figure 1 shows statistically-significant win/loss differences for each of the algorithms, across these 16 shuffles. Each row/column entry shows the number of times the row algorithm won against the column, minus the number of losses. MELˆ EE´ is the only algorithm that always wins more than it loses against other algorithms, and outperforms the nearest competition ( $\\epsilon$ -decreasing) by 3 points. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3.2 SIMULATED CONTEXTUAL BANDIT TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            618,
+            524,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We additionally perform an exhaustive evaluation on simulated contextual bandit tasks to ensure that the performance of MELˆ EE´ generalizes beyond learning to rank. Following Bietti et al. (2018), we use a collection of 300 binary classification datasets from openml.org for evaluation; the precise list and download instructions is in $\\ S \\mathbf { A } . 3$ . These datasets cover a variety of different domains including text $\\&$ image processing, medical, and sensory data. We convert classification datasets into cost-sensitive classification problems by using a $0 / 1$ encoding. Given these fully supervised cost-sensitive multi-class datasets, we simulate the contextual bandit setting by only revealing the reward for the selected actions. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            755
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2 (left), we show a representative learning curve. Here, we see that as more data becomes available, all the approaches improve (except $\\tau$ -first, which has ceased to learn after $2 \\%$ of the data). MELˆ EE´ , in particular, is able to very quickly achieve near-optimal performance (in around 40 examples) in comparison to the best baseline which takes at least 200. In Figure 2 (right), we show the CDFs for the different algorithms. To help read this, at $x = 1 . 0$ , MELˆ EE´ has a relative reward at least 1.0 on more than $40 \\%$ of datasets, while $\\epsilon$ -decreasing and $\\epsilon$ -greedy achieve this on about $30 \\%$ of datasets. We find that the two strongest baselines are $\\epsilon$ -decreasing and $\\epsilon$ -greedy (better when reward differences are small, toward the left of the graph). The two curves for $\\epsilon$ -decreasing and $\\epsilon$ - greedy coincide. This happens because the exploration probability $\\epsilon _ { 0 }$ for $\\epsilon$ -decreasing decays rapidly approaching zero with a rate of $\\textstyle { \\frac { 1 } { t } }$ , where $t$ is the index of the current round. MELˆ EE´ outperforms the baselines in the “large reward” regimes (right of graph) but under-performs $\\epsilon$ -decreasing and $\\epsilon$ -greedy in low reward regimes (left of graph). ",
+        "bbox": [
+            174,
+            761,
+            825,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b1788988d738da0efcd31535810491c3b39d1eba306ed5431107fee49afac2b5.jpg",
+        "image_caption": [
+            "Figure 1: Results for the Learning to Rank task. (Left) Learning curve on the MSLR-10K dataset: $\\mathbf { X }$ -axis shows the number of queries observed, and y-axis shows the progressive reward. (Right) Win/Loss counts for all pairs of algorithms over 16 random shuffles for the MSLR-10K dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            102,
+            797,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6888bb6073c77103de6a8010443f100180a1163ae34fbd197c0760f993ad28e5.jpg",
+        "image_caption": [
+            "Figure 2: Behavior of MELˆ EE´ in comparison to baseline and state-of-the-art exploration algorithms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            460,
+            828,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            755,
+            825,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3, we show statistically-significant win/loss differences for each of the algorithms. Here, each (row, column) entry shows the number of times the row algorithm won against the column, minus the number of losses. MELˆ EE´ is the only algorithm that always wins more than it loses against other algorithms, and outperforms the nearest competition ( $\\epsilon$ -decreasing) by 23 points. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To understand more directly how MELˆ EE´ compares to $\\epsilon$ -decreasing, in the left plot of Figure 4, we show a scatter plot of rewards achieved by MELˆ EE´ $\\mathbf { \\dot { X } }$ -axis) and $\\epsilon$ -decreasing (y-axis) on each of the 300 datasets, with statistically significant differences highlighted in red and insignificant differences in blue. Points below the diagonal line correspond to better performance by MELˆ EE´ (147 datasets) ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e5f7991d2955d71f4a06f822d4d7174981f8622bdddcce1efae21f30ba0af0b.jpg",
+        "image_caption": [
+            "Figure 3: Win/Loss counts for all pairs of algorithms (columns match the rows). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            101,
+            651,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/f000364f695f671698bcf02790d820913e704e54048dceca345b44fcdbac3291.jpg",
+        "image_caption": [
+            "Figure 4: Scatterplots comparing MELˆ EE´ to the best baseline and to a variant with fewer features. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            168,
+            388,
+            821,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "and points above to $\\epsilon$ -decreasing (124 datasets). The remaining 29 had no statistically significant difference. ",
+        "bbox": [
+            173,
+            612,
+            821,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we consider the effect that the additional features have on MELˆ EE´ ’s performance. In particular, we consider a version of MELˆ EE´ with all features (this is the version used in all other experiments) with an ablated version that only has access to the (calibrated) probabilities of each action from the underlying classifier $f$ . The comparison is shown as a scatter plot in Figure 4 (right). Here, we can see that the full feature set does provide lift over just the calibrated probabilities, with a win-minus-loss improvement of 24 by adding additional features from which to learn to explore. ",
+        "bbox": [
+            173,
+            646,
+            825,
+            731
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            752,
+            495,
+            768
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The field of meta-learning is based on the idea of replacing hand-engineered learning heuristics with heuristics learned from data. One of the most relevant settings for meta-learning to ours is active learning, in which one aims to learn a decision function to decide which examples, from a pool of unlabeled examples, should be labeled. Past approaches to meta-learning for active learning include reinforcement learning-based strategies (Woodward & Finn, 2017; Fang et al., 2017), imitation learning-based strategies (Bachman et al., 2017), and batch supervised learning-based strategies (Konyushkova et al., 2017). Similar approaches have been used to learn heuristics for optimization (Li & Malik, 2016; Andrychowicz et al., 2016), multiarm (non-contextual) bandits Maes et al. (2012), and neural architecture search (Zoph & Le, 2016), recently mostly based on (deep) reinforcement learning. While meta-learning for contextual bandits is most similar to meta-learning for active learning, there is a fundamental difference that makes it significantly more challenging: in active learning, the goal is to select as few examples as you can to learn, so by definition the horizon is short; in contextual bandits, learning to explore is fundamentally a long-horizon problem, because what matters is not immediate reward but long term learning. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In reinforcement learning, Gupta et al. (2018) investigated the task of meta-learning an exploration strategy for a distribution of related tasks by learning a latent exploration space. Similarly, Xu et al. (2018) proposed a teacher-student approach for learning to do exploration in off-policy reinforcement learning. While these approaches are effective if the distribution of tasks is very similar and the state space is shared among different tasks, they fail to generalize when the tasks are different. Our approach targets an easier problem than exploration in full reinforcement learning environments, and can generalize well across a wide range of different tasks with completely unrelated features spaces. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There has also been a substantial amount of work on constructing “good” exploration policies, in problems of varying complexity: traditional bandit settings (Karnin & Anava, 2016), contextual bandits (Fraud et al., 2016) and reinforcement learning (Osband et al., 2016). In both bandit settings, most of this work has focused on the learning theory aspect of exploration: what exploration distributions guarantee that learning will succeed (with high probability)? MELˆ EE´ , lacks such guarantees: in particular, if the data distribution of the observed contexts $( \\phi ( f _ { t } ) )$ in some test problem differs substantially from that on which MELˆ EE´ was trained, we can say nothing about the quality of the learned exploration. Nevertheless, despite fairly substantial distribution mismatch (synthetic real-world), MELˆ EE´ works well in practice, and our stylized theory $( \\ S 4 )$ suggests that there may be an interesting avenue for developing strong theoretical results for contextual bandit learning with learned exploration policies, and perhaps other meta-learning problems. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            438
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In conclusion, we presented MELˆ EE´ , a meta-learning algorithm for learning exploration policies in the contextual bandit setting. MELˆ EE´ enjoys no-regret guarantees, and empirically it outperforms alternative exploration algorithm in most settings. One limitation of MELˆ EE´ is the computational resources required during the offline training phase on the synthetic datasets. In the future, we will work on improving the computational efficiency for MELˆ EE´ in the offline training phase and scale the experimental analysis to problems with larger number of classes. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            285,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alekh Agarwal, Daniel Hsu, Satyen Kale, John Langford, Lihong Li, and Robert E. Schapire. Taming the monster: A fast and simple algorithm for contextual bandits. In In Proceedings of the 31st International Conference on Machine Learning (ICML-14, pp. 1638–1646, 2014.   \nMarcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, pp. 3981–3989, 2016.   \nPeter Auer. Using confidence bounds for exploitation-exploration trade-offs. The Journal of Machine Learning Research, 3:397–422, 2003.   \nPhilip Bachman, Alessandro Sordoni, and Adam Trischler. Learning algorithms for active learning. In ICML, 2017.   \nAlina Beygelzimer and John Langford. The offset tree for learning with partial labels. In Proceedings of the 15th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 129–138. ACM, 2009.   \nAlberto Bietti, Alekh Agarwal, and John Langford. A Contextual Bandit Bake-off. working paper or preprint, May 2018.   \nAvrim Blum, Adam Kalai, and John Langford. Beating the hold-out: Bounds for k-fold and progressive cross-validation. In Proceedings of the twelfth annual conference on Computational learning theory, pp. 203–208. ACM, 1999.   \nLeo Breiman. Random forests. Mach. Learn., 45(1):5–32, October 2001. ISSN 0885-6125. doi: 10.1023/A:1010933404324. ",
+        "bbox": [
+            169,
+            571,
+            825,
+            929
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai-Wei Chang, Akshay Krishnamurthy, Alekh Agarwal, Hal Daume, III, and John Langford. ´ Learning to search better than your teacher. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML, pp. 2058–2066. JMLR.org, 2015. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hal Daume, III, John Langford, and Daniel Marcu. Search-based structured prediction. ´ Machine Learning, 75(3):297–325, Jun 2009. ISSN 1573-0565. doi: 10.1007/s10994-009-5106-x. ",
+        "bbox": [
+            174,
+            169,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Miroslav Dudik, Daniel Hsu, Satyen Kale, Nikos Karampatziakis, John Langford, Lev Reyzin, and Tong Zhang. Efficient optimal learning for contextual bandits. arXiv preprint arXiv:1106.2369, 2011. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Meng Fang, Yuan Li, and Trevor Cohn. Learning how to active learn: A deep reinforcement learning approach. In EMNLP, 2017. ",
+        "bbox": [
+            173,
+            260,
+            823,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Raphal Fraud, Robin Allesiardo, Tanguy Urvoy, and Fabrice Clrot. Random forest for the contextual bandit problem. In Arthur Gretton and Christian C. Robert (eds.), Proceedings of the 19th International Conference on Artificial Intelligence and Statistics, volume 51 of Proceedings of Machine Learning Research, pp. 93–101, Cadiz, Spain, 09–11 May 2016. PMLR. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Gupta, Russell Mendonca, YuXuan Liu, Pieter Abbeel, and Sergey Levine. Metareinforcement learning of structured exploration strategies. arXiv preprint arXiv:1802.07245, 2018. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "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,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leslie Pack Kaelbling. Associative reinforcement learning: Functions ink-dnf. Machine Learning, 15(3):279–298, 1994. ",
+        "bbox": [
+            173,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sham M. Kakade, Shai Shalev-Shwart, and Ambuj Tewari. Efficient bandit algorithms for online multiclass prediction. In ICML, 2008. ",
+        "bbox": [
+            171,
+            492,
+            823,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zohar S Karnin and Oren Anava. Multi-armed bandits: Competing with optimal sequences. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 199–207. Curran Associates, Inc., 2016. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ksenia Konyushkova, Raphael Sznitman, and Pascal Fua. Learning active learning from data. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            174,
+            582,
+            821,
+            612
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Langford and Bianca Zadrozny. Relating reinforcement learning performance to classification performance. In Proceedings of the 22nd international conference on Machine learning, pp. 473–480. ACM, 2005. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Langford and Tong Zhang. The epoch-greedy algorithm for multi-armed bandits with side information. In Advances in Neural Information Processing Systems 20, pp. 817–824. Curran Associates, Inc., 2008. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            715
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ke Li and Jitendra Malik. Learning to optimize. arXiv preprint arXiv:1606.01885, 2016. ",
+        "bbox": [
+            169,
+            724,
+            758,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lihong Li, Wei Chu, John Langford, and Robert E. Schapire. A contextual-bandit approach to personalized news article recommendation. In Proceedings of the 19th International Conference on World Wide Web, WWW ’10, pp. 661–670, New York, NY, USA, 2010a. ACM. ISBN 978-1- 60558-799-8. doi: 10.1145/1772690.1772758. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            806
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Li, Xuerui Wang, Ruofei Zhang, Ying Cui, Jianchang Mao, and Rong Jin. Exploitation and exploration in a performance based contextual advertising system. In Proceedings of the 16th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’10, pp. 27–36, New York, NY, USA, 2010b. ACM. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hsuan-Tien Lin, Chih-Jen Lin, and Ruby C. Weng. A note on platt’s probabilistic outputs for support vector machines. Machine Learning, 68(3):267–276, Oct 2007. ISSN 1573-0565. doi: 10.1007/s10994-007-5018-6. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francis Maes, Louis Wehenkel, and Damien Ernst. Meta-learning of exploration/exploitation strategies: The multi-armed bandit case. In International Conference on Agents and Artificial Intelligence, pp. 100–115. Springer, 2012. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped dqn. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4026–4034. Curran Associates, Inc., 2016. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            210
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            276
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonas Peters, Joris M Mooij, Dominik Janzing, and Bernhard Scholkopf. Causal discovery with ¨ continuous additive noise models. The Journal of Machine Learning Research, 15(1):2009–2053, 2014. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            328
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John C. Platt. Probabilistic outputs for support vector machines and comparisons to regularized likelihood methods. In ADVANCES IN LARGE MARGIN CLASSIFIERS, pp. 61–74. MIT Press, 1999. ",
+        "bbox": [
+            173,
+            337,
+            826,
+            380
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tao Qin and Tie-Yan Liu. Introducing LETOR 4.0 datasets. CoRR, abs/1306.2597, 2013. URL http://arxiv.org/abs/1306.2597. ",
+        "bbox": [
+            171,
+            388,
+            823,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross and J Andrew Bagnell. Reinforcement and imitation learning via interactive no-regret ´ learning. arXiv preprint arXiv:1406.5979, 2014. ",
+        "bbox": [
+            169,
+            426,
+            825,
+            455
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey Gordon, and J Andrew Bagnell. A reduction of imitation learning and ´ structured prediction to no-regret online learning. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, volume 15 of Proceedings of Machine Learning Research, pp. 627–635, Fort Lauderdale, FL, USA, 11–13 Apr 2011. PMLR. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton. Generalization in reinforcement learning: Successful examples using sparse coarse coding. In Advances in neural information processing systems, pp. 1038–1044, 1996. ",
+        "bbox": [
+            171,
+            529,
+            823,
+            559
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981. ",
+        "bbox": [
+            171,
+            568,
+            823,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mark Woodward and Chelsea Finn. Active one-shot learning. arXiv preprint arXiv:1702.06559, 2017. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tianbing Xu, Qiang Liu, Liang Zhao, Wei Xu, and Jian Peng. Learning to explore with meta-policy gradient. arXiv preprint arXiv:1803.05044, 2018. ",
+        "bbox": [
+            171,
+            642,
+            823,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chicheng Zhang, Alekh Agarwal, Hal Daume, III, John Langford, and Sahand N Negahban. Warm- ´ starting contextual bandits: Robustly combining supervised and bandit feedback. In ICML, 2019. ",
+        "bbox": [
+            171,
+            680,
+            823,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            171,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Supplementary Material For: Learning Effective Exploration Strategies for Contextual Bandits ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            785,
+            137
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A STYLIZED TEST-TIME ANALYSIS FOR BANDITRON: DETAILS ",
+        "bbox": [
+            176,
+            155,
+            707,
+            171
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The BANDITRONMELˆ EE´ algorithm is specified in $\\mathrm { A l g } 2$ . The is exactly the same as the typical test time behavior, except it uses a BANDITRON-type strategy for learning the underlying classifier $f$ in the place of POLOPT. POLICYELIMINATIONMETA takes as arguments: $\\pi$ (the learned exploration policy) and $\\mu \\in ( 0 , 1 / ( 2 K ) )$ an added uniform exploration parameter. The BANDITRON learns a linear multi-class classifier parameterized by a weight matrix of size $K { \\times } D$ , where $D$ is the input dimensionality. The BANDITRON assumes a pure multi-class setting in which the reward for one (“correct”) action is 1 and the reward for all other actions is zero. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            284
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "At each round $t$ , a prediction $\\hat { a } _ { t }$ is made according to $f _ { t }$ (summarized by $W ^ { t }$ ). We then define an exploration distribution that “most of the time” acts according to $\\pi ( f _ { t } , . )$ , but smooths each action with $\\mu$ probability. The chosen action $a _ { t }$ is sampled from this distribution and a binary reward is observed. The weights of the BANDITRON are updated according to the BANDITRON update rule using $\\tilde { U } ^ { t }$ . ",
+        "bbox": [
+            174,
+            290,
+            825,
+            362
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 BANDITRONMELˆ EE´ $( g , \\mu )$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            376,
+            446,
+            391
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1: initialize $W ^ { 1 } = \\mathbf { 0 } \\in \\mathbb { R } ^ { K \\times D }$   \n2: for rounds $t = 1 \\dots T$ : do   \n3: observe $\\boldsymbol { x } _ { t } \\in \\mathbb { R } ^ { D }$   \n4: compute $\\begin{array} { r } { \\hat { a } _ { t } = f _ { t } ( x _ { t } ) = \\mathrm { a r g m a x } _ { k \\in K } \\left( W ^ { t } x _ { t } \\right) _ { k } } \\end{array}$   \n5: define $Q ^ { \\mu } ( a ) = \\mu + ( 1 - K \\mu ) { \\bf 1 } [ a = \\pi ( W ^ { t } , x _ { t } ) ]$   \n6: sample $a _ { t } \\sim Q ^ { \\mu }$   \n7: observe reward $r _ { t } ( a _ { t } ) \\in \\{ 0 , 1 \\}$   \n8: d $\\tilde { U } ^ { t } \\in \\mathbb { R } ^ { K \\times D }$   \n$\\begin{array} { r } { \\tilde { U } _ { a , \\cdot } ^ { t } = x _ { t } \\left( \\frac { \\mathbf { 1 } [ r _ { t } ( a _ { t } ) = 1 ] \\mathbf { 1 } [ a _ { t } = a ] } { Q ^ { \\mu } ( a ) } - \\mathbf { 1 } [ \\hat { a } _ { t } = a ] \\right) } \\end{array}$   \n9: update $W ^ { t + 1 } = W ^ { t } + \\tilde { U } ^ { t }$ ",
+        "bbox": [
+            179,
+            393,
+            542,
+            547
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The only difference between BANDITRONMELˆ EE´ and the original BANDITRON is the introduction of $\\pi$ in the sampling distribution. The original algorithm achieves the following mistake bound shown below, which depends on the notion of multi-class hinge-loss. In particular, the hinge-loss of $W$ on $( x , r )$ is $\\ell ( W , ( x , \\pmb { r } ) ) = \\mathrm { m a x } _ { a \\neq a ^ { \\star } }$ max $\\left\\{ 0 , 1 - ( W x ) _ { a ^ { \\star } } + ( W x ) _ { a } ^ { \\top } \\right\\}$ , where $a ^ { \\star }$ is the $a$ for which $r ( a ) = 1$ . The overall hinge-loss $L$ is the sum of $\\ell$ over the sequence of examples. ",
+        "bbox": [
+            173,
+            577,
+            825,
+            650
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Thm. 1 and Corr. 2 of Kakade et al. (2008)) Assume that for the sequence of examples, $( x _ { 1 } , r _ { 1 } ) , ( x _ { 2 } , r _ { 2 } ) , \\ldots , ( x _ { T } , \\pmb { r } _ { T } )$ , we have, for all $t _ { : }$ , $| | x _ { t } | | \\leq 1$ . Let $W ^ { \\star }$ be any matrix, let $L$ be the cumulative hinge-loss of $W ^ { \\star }$ , and let $D = 2 \\left| \\left| W ^ { \\star } \\right| \\right| _ { F } ^ { 2 }$ be the complexity of $W ^ { \\star }$ . The number of mistakes $M$ made by the BANDITRON satisfies ",
+        "bbox": [
+            173,
+            659,
+            825,
+            717
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c7e337e2f2c2052151da2a1b413827d1f6ad201796ab3f0ed0bf40986778eff.jpg",
+        "text": "$$\n{ \\mathbb { E } } M \\leq L + K \\mu T + 3 \\operatorname* { m a x } \\left\\{ { \\frac { D } { \\mu } } , { \\sqrt { D T K \\mu } } \\right\\} + { \\sqrt { D L / \\mu } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            717,
+            691,
+            751
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is taken with respect to the randomness of the algorithm. Furthermore, in a low noise setting (there exists $W ^ { \\star }$ with fixed complexity √ $d$ and loss $\\bar { L ( \\mathbf { \\Omega } \\leq \\cal { O } ( \\sqrt { \\cal { D } K T } ) ) }$ , then by setting $\\mu = \\sqrt { D / ( T K ) }$ , we obtain $\\mathbb { E } M \\le O ( \\sqrt { K D T } )$ . ",
+        "bbox": [
+            174,
+            750,
+            825,
+            795
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We can prove an analogous result for BANDITRONMELˆ EE´ . The key quantity that will control how much $\\pi$ improves the execution of BANDITRONMELˆ EE´ is how much $\\pi$ improves on $f _ { t }$ when $f _ { t }$ is $\\pi ( f _ { t } , . )$ In p over $f$ ticul, and $\\begin{array} { r } { \\Gamma = \\frac { 1 } { T } \\sum _ { t = 1 } ^ { T } \\mathbb { E } \\frac { 1 } { 1 + K \\gamma _ { t } } } \\end{array}$ $\\gamma _ { t } = \\operatorname* { P r } [ r _ { t } ( \\pi ( f _ { t } , x _ { t } ) = 1 ) | x _ { t } ] - \\operatorname* { P r } [ r _ { t } ( f _ { t } ( x _ { t } ) ) = 1 | x _ { t } ]$ $\\pi$ e the edge ofdoes nothing, then all $\\gamma _ { t } = 0$ $\\Gamma = 1 .$ .) Given this quantity, we can prove the following Theorem 2. ",
+        "bbox": [
+            173,
+            803,
+            825,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof: [sketch] The proof is a small modification of the original proof of Theorem 3. The only change is that in the original proof, the following bound is used: $\\mathbb { E } _ { t } | | \\bar { \\tilde { U } } ^ { t } | | ^ { 2 } / | | x _ { t } | | ^ { 2 } = 1 + 1 / \\mu \\le 2 / \\mu$ ",
+        "bbox": [
+            173,
+            893,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use, instead: Et||U˜ t||2/||xt||2 ≤ 1 + Et 1µ+γt 2Et 11+γtµ . The rest of the proof goes through identically. ",
+        "bbox": [
+            174,
+            101,
+            825,
+            138
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 DETAILS OF SYNTHETIC DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            464,
+            167
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We generate datasets with uniformly distributed class conditional distributions. We generate 2D datasets by first sampling a random variable representing the Bayes classification error. The Bayes error is sampled uniformly from the interval 0.0 to 0.5. Next, we generate a balanced dataset where the data for each class lies within a unit rectangle and sampled uniformly. We overlap the sampling rectangular regions to generate a dataset with the desired Bayes error selected in the first step. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            250
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            266,
+            410,
+            280
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Our implementation is based on scikit-learn (Pedregosa et al., 2011). We fix the training time exploration parameter $\\mu$ to 0.1. We train the exploration policy $\\pi$ on 82 synthetic datasets each of size 3000 with uniform class conditional distributions, a total of $2 4 6 k$ samples (§A.1). We train $\\pi$ using a linear classifier Breiman (2001) and set the hyper-parameters for the learning rate, and data scaling methods using three-fold cross-validation on the whole meta-training dataset. For the classifier class $\\mathcal { F }$ , we use a linear model trained with stochastic gradient descent. We standardize all features to zero mean and unit variance, or scale the features to lie between zero and one. To select between the two scaling methods, and tune the classifier’s learning rate, we use three-fold cross-validation on a small fully supervised training set of size 30 samples. The same set is used to calibrate the predicted probabilities of $f _ { t }$ . ",
+        "bbox": [
+            173,
+            291,
+            825,
+            431
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 LIST OF DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            446,
+            349,
+            460
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The datasets we used can be accessed at https://www.openml.org/d/<id>. The list of (id, size) pairs below shows the (id for the datasets we used and the dataset size in number of examples: ",
+        "bbox": [
+            174,
+            473,
+            825,
+            515
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(46,100) (716, 100) (726, 100) (754, 100) (762, 100) (768, 100) (775, 100) (783, 100) (789, 100) (808, 100) (812, 100) (828, 100) (829, 100) (850, 100) (865, 100) (868, 100) (875, 100) (876, 100) (878, 100) (916, 100) (922, 100) (932, 100) (1473, 100) (965, 101) (1064, 101) (956, 106) (1061, 107) (771, 108) (736, 111) (448, 120) (782, 120) (1455, 120) (1059, 121) (1441, 123) (714, 125) (867, 130) (924, 130) (1075, 130) (1141, 130) (885, 131) (444, 132) (921, 132) (974, 132) (719, 137) (1013, 138) (1151, 138) (784, 140) (1045, 145) (1066, 145) (1125, 146) (902, 147) (1006, 148) (969, 150) (955, 151) (1026, 155) (745, 159) (756, 159) (1085, 159) (1054, 161) (748, 163) (747, 167) (973, 178) (463, 180) (801, 185) (1164, 185) (788, 186) (1154, 187) (941, 189) (1131, 193) (753, 194) (1012, 194) (1155, 195) (1488, 195) (446, 200) (721, 200) (1124, 201) (1132, 203) (40, 208) (733, 209) (796, 209) (996, 214) (1005, 214) (895, 222) (1412, 226) (820, 235) (851, 240) (464, 250) (730, 250) (732, 250) (744, 250) (746, 250) (763, 250) (769, 250) (773, 250) (776, 250) (793, 250) (794, 250) (830, 250) (832, 250) (834, 250) (863, 250) (873, 250) (877, 250) (911, 250) (918, 250) (933, 250) (935, 250) (1136, 250) (778, 252) (1442, 253) (1449, 253) (1159, 259) (450, 264) (811, 264) (336, 267) (1152, 267) (53, 270) (1073, 274) (1156, 275) (880, 284) (1121, 294) (43, 306) (818, 310) (915, 315) (1157, 321) (1162, 322) (925, 323) (1140, 324) (1144, 329) (1011, 336) (1147, 337) (1133, 347) (337, 349) (59, 351) (1135, 355) (1143, 363) (1048, 369) (860, 380) (1129, 384) (1163, 386) (900, 400) (906, 400) (907, 400) (908, 400) (909, 400) (1025, 400) (1071, 403) (1123, 405) (1160, 410) (1126, 412) (1122, 413) (1127, 421) (764, 450) (1065, 458) (1149, 458) (1498, 462) (724, 468) (814, 468) (1148, 468) (1150, 470) (765, 475) (767, 475) (1153, 484) (742, 500) (749, 500) (750, 500) (766, 500) (779, 500) (792, 500) (805, 500) (824, 500) (838, 500) (855, 500) (869, 500) (870, 500) (879, 500) (884, 500) (886, 500) (888, 500) (896, 500) (920, 500) (926, 500) (936, 500) (937, 500) (943, 500) (987, 500) (1470, 500) (825, 506) (853, 506) (872, 506) (717, 508) (1063, 522) (954, 531) (1467, 540) (1165, 542) (1137, 546) (335, 554) (333, 556) (947, 559) (949, 559) (950, 559) (951, 559) (826, 576) (1004, 600) (334, 601) (1158, 604) (770, 625) (997, 625) (1145, 630) (1443, 661) (774, 662) (795, 662) (827, 662) (931, 662) (292, 690) (1451, 705) (1464, 748) (37, 768) (1014, 797) (970, 841) (994, 846) (841, 950) (50, 958) (1016, 990) (31, 1000) (715, 1000) (718, 1000) (723, 1000) (740, 1000) (743, 1000) (751, 1000) (797, 1000) (799, 1000) (806, 1000) (813, 1000) (837, 1000) (845, 1000) (849, 1000) (866, 1000) (903, 1000) (904, 1000) (910, 1000) (912, 1000) (913, 1000) (917, 1000) (741, 1024) (1444, 1043) (1453, 1077) ",
+        "bbox": [
+            171,
+            521,
+            826,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(1068, 1109) (934, 1156) (1049, 1458) (1454, 1458) (983, 1473) (1128, 1545) (1130, 1545) (1138, 1545) (1139, 1545) (1142, 1545) (1146, 1545) (1161, 1545) (1166, 1545) (1050, 1563) (991, 1728) (962, 2000) (971, 2000) (978, 2000) (995, 2000) (1020, 2000) (1022, 2000) (914, 2001) (1067, 2109) (772, 2178) (948, 2178) (958, 2310) (312, 2407) (1487, 2534) (737, 3107) (953, 3190) (3, 3196) (1038, 3468) (871, 3848) (728, 4052) (720, 4177) (1043, 4562) (44, 4601) (979, 5000) (1460, 5300) (1489, 5404) (1021, 5473) (1069, 5589) (980, 5620) (847, 6574) (1116, 6598) (803, 7129) (1496, 7400) (725, 8192) (735, 8192) (752, 8192) (761, 8192) (807, 8192) ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 BASELINE EXPLORATION ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            218,
+            493,
+            232
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Our experiments aim to determine how MELˆ EE´ compares to other standard exploration strategies. In particular, we compare to: ",
+        "bbox": [
+            171,
+            243,
+            823,
+            272
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$\\epsilon$ -greedy: With probability $\\epsilon$ , explore uniformly at random; with probability $1 - \\epsilon$ act greedily according to $f _ { t }$ (Sutton, 1996). Experimentally, we found $\\epsilon = 0$ optimal on average, consistent with the results of Bietti et al. (2018). ",
+        "bbox": [
+            176,
+            280,
+            823,
+            321
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$\\epsilon$ -decreasing: selects a random action with probabilities $\\epsilon _ { i }$ , where $\\epsilon _ { i } = \\epsilon _ { 0 } / t , \\epsilon _ { 0 } \\in ] 0 , 1 ]$ and $t$ is the index of the current round. In our experiments we set $\\epsilon _ { 0 } = 0 . 1$ . (Sutton & Barto, 1998) ",
+        "bbox": [
+            176,
+            321,
+            821,
+            349
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Exponentiated Gradient $\\epsilon$ -greedy: maintains a set of candidate values for $\\epsilon$ -greedy exploration. At each iteration, it runs a sampling procedure to select a new $\\epsilon$ from a finite set of candidates. The probabilities associated with the candidates are initialized uniformly and updated with the Exponentiated Gradient (EG) algorithm. Following Li et al. (2010b), we use the candidate set $\\{ \\epsilon _ { i } = 0 . 0 5 { \\times } i + 0 . 0 1 , i = 1 , \\cdot \\cdot \\cdot , 1 0 \\}$ for $\\epsilon$ . ",
+        "bbox": [
+            174,
+            349,
+            825,
+            417
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "LinUCB: Maintains confidence bounds for reward payoffs and selects actions with the highest confidence bound. It is impractical to run “as is” due to high-dimensional matrix inversions. We use diagonal approximation to the covariance when the dimensions exceeds 150. (Li et al., 2010a) $\\tau$ -first: Explore uniformly on the first $\\tau$ fraction of the data; after that, act greedily. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            473
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Cover: Maintains a uniform distribution over a fixed number of policies. The policies are used to approximate a covering distribution over policies that are good for both exploration and exploitation (Agarwal et al., 2014). ",
+        "bbox": [
+            176,
+            474,
+            820,
+            515
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Cover Non-Uniform: similar to Cover, but reduces the level of exploration of Cover to be more competitive with the Greedy method. Cover-Nu doesn’t add extra exploration beyond the actions chose by the covering policies (Bietti et al., 2018). ",
+        "bbox": [
+            176,
+            515,
+            823,
+            558
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In all cases, we select the best hyperparameters for each exploration algorithm following Bietti et al. (2018). These hyperparameters are: the choice of $\\epsilon$ in $\\epsilon$ -greedy, $\\tau$ in $\\tau$ -first, the number of bags, and the tolerance $\\psi$ for Cover and Cover-NU. We set $\\epsilon = 0 . 0$ , $\\tau = 0 . 0 2$ , bag size $= 1 6$ , and $\\psi = 0 . 1$ . ",
+        "bbox": [
+            173,
+            564,
+            823,
+            606
+        ],
+        "page_idx": 14
+    }
+]

parse/train/H1fsUiRcKQ/H1fsUiRcKQ.md

@@ -0,0 +1,384 @@
+# FAST ADVERSARIAL TRAINING FOR SEMI-SUPERVISEDLEARNING
+
+Anonymous authors
+
+Paper under double-blind review
+
+# ABSTRACT
+
+In semi-supervised learning, Bad GAN approach is one of the most attractive method due to the intuitional simplicity and powerful performances. Bad GAN learns a classifier with bad samples distributed on complement of the support of the input data. But Bad GAN needs additional architectures, a generator and a density estimation model, which involves huge computation and memory consumption cost. VAT is another good semi-supervised learning algorithm, which utilizes unlabeled data to improve the invariance of the classifier with respect to perturbation of inputs. In this study, we propose a new method by combining the ideas of Bad $G A N$ and VAT. The proposed method generates bad samples of high-quality by use of the adversarial training used in VAT. We give theoretical explanations why the adversarial training is good at both generating bad samples and semi-supervised learning. An advantage of the proposed method is to achieve the competitive performances with much fewer computations. We demonstrate advantages our method by various experiments with well known benchmark image datasets.
+
+# 1 INTRODUCTION
+
+Deep learning has accomplished unprecedented success due to the development of deep architectures, learning techniques and hardwares (Krizhevsky et al., 2012; Ioffe & Szegedy, 2015; Szegedy et al., 2015; Hinton et al., 2012; Kingma & Ba, 2014). However, deep learning has also suffered from collecting large amount of labeled data which requires both cost and time. Thus it becomes important to develop semi-supervised methodologies that learn a classifier (or discriminator) by using small labeled data and large unlabeled data.
+
+Various semi-supervised learning methods have been proposed for deep learning. Weston et al. (2012) employs a manifold embedding technique using the pre-constructed graph of unlabeled data and Rasmus et al. (2015) uses a specially designed auto-encoder to extract essential features for classification. Variational auto encoder (Kingma & Welling, 2013) is also used in the context of semi-supervised learning by maximizing the variational lower bound of both labeled and unlabeled data (Kingma et al., 2014; Maaløe et al., 2016).
+
+Recently, semi-supervised learning based on generative adversarial networks (GAN, Goodfellow et al. (2014a)) has received much attention. For $K$ -class classification problems, Salimans et al. (2016) solves the $( K + 1 )$ -class classification problem where the additional $( K + 1 )$ th class consists of synthetic images made by a generator of the $G A N$ learned by unlabeled data. Dai et al. (2017) notices that not a good generator but a bad generator which generates synthetic images much different from observed images is crucial for the success of semi-supervised learning. Dai et al. (2017) gives theoretical justifications of using a bad generator and develops a semi-supervised learning algorithm called Bad GAN which achieves the state-of-the-art performances over multiple benchmark datasets.
+
+However, Bad GAN has several limitations. It needs two additional deep architectures - bad generator and pre-trained density estimation model besides the one for the classifier. Learning these multiple deep architectures requires huge computation and memory consumption. In particular, the Pixel$C N N { + + }$ (Salimans et al., 2017) is used for the pre-trained density estimation model which needs very large computational resources.
+
+Another difficulty in Bad GAN is that it requires a two-step learning procedure - the first step is to learn the $P i x e l C N N { + + }$ model and the second step is to learn the classifier and the bad generator. The optimal learning of the first step may not be optimal for the second step and hence the regularization of the both steps would need special techniques.
+
+In this study, we propose a new semi-supervised learning method which competes well with other stateof-the-art semi-supervised learning algorithms and yet needs much smaller amount of computational resources. In particular, the proposed method employs only one deep architecture and hence the corresponding learning phase is much easier and faster.
+
+Our proposed method is motivated by close investigation of VAT (Virtual Adversarial Training) method (Miyato et al., 2015; 2017). VAT tries to find a deep classifier which has a good prediction accuracy on training data and at the same time is less sensitive to data perturbation toward the adversarial direction. Here, the adversarial direction for a given datum is the direction to which the probabilities of each class change most. In Section 3, we prove that the perturbed data toward their adversarial directions can serve as ‘good’ bad samples. By using the adversarial directions for both measuring the invariance and generating the bad samples, the proposed method combines the advantages of Bad GAN and VAT together. Note that only a deep architecture for classification is needed to calculate the adversarial directions and thus the corresponding learning procedure is cheaper, easier and faster. We call our proposed method FAT (Fast Adversarial Training).
+
+Dai et al. (2017) proves that bad samples play a role to pull the decision boundary toward the low density regions of data. In Section 5, we give a theoretical explanation that VAT pushes the decision boundary away from the high density regions of data. That is, FAT accelerates the learning procedure by using both pushing and pulling operations simultaneously. In section 6, we show that $F A T$ achieves almost the state-of-the-art performances with much fewer training epochs. Especially, for the MNIST dataset, FAT achieves similar test accuracies to those of Bad GAN and VAT with 5 times and 7 times fewer training epochs, respectively.
+
+This paper is organized as follows. In Section 2, we review the Bad GAN and VAT methods briefly. In Section 3, the technique to generate bad samples using the adversarial directions is described, and our proposed semi-supervised learning method is presented in Section 4. Theoretical analysis of VAT is given in Section 5. Results of various experiments are presented in Section 6 and conclusions follow in Section 7.
+
+# 2 Bad GAN AND VAT
+
+# 2.1 Bad GAN APPROACH
+
+Bad GAN is a method that trains a good discriminator with a bad generator. This procedure trains a generator as well as a discriminator simultaneously. Let $\mathcal { D } _ { G } ( \phi )$ be generated bad samples with a bad generator $p _ { G } ( \cdot ; \phi )$ parametrized by $\phi$ . Here, the ‘bad generator’ is a deep architecture to generate samples different from observed data. Let $p ^ { \mathrm { p t } } ( \cdot )$ be a pre-trained density estimation model. For a given discriminator with a feature vector $v ( x ; \theta )$ of a given input $x$ parameterized by $\theta$ , Bad GAN learns the bad generator by minimizing the following:
+
+$$
+\mathbb { E } _ { x \sim \mathcal { D } _ { G } ( \phi ) } \left[ \log p ^ { \mathrm { p t } } ( x ) \mathbb { I } ( p ^ { \mathrm { p t } } ( x ) > \tau ) \right] + | | \mathbb { E } _ { x \sim \mathcal { U } ^ { t r } } v ( x ; \widehat { \theta } ) - \mathbb { E } _ { x \sim \mathcal { D } _ { G } ( \phi ) } v ( x ; \widehat { \theta } ) | | ^ { 2 }
+$$
+
+with respect to $\phi$ , where $\tau > 0$ is a tuning parameter, $\boldsymbol { \mathcal { U } } ^ { t r }$ is the unlabeled data, and $\widehat { \theta }$ is the current estimate of $\theta$ and $\| \cdot \|$ is the Euclidean norm.
+
+In turn, to train the discriminator, we consider the $K$ -class classification problem as the $( K + 1 )$ -class classification problem where the $( K + 1 )$ -th class is an artificial label of the bad samples generated by the bad generator. We estimate the parameter $\theta$ in the discriminator by minimizing the following:
+
+$$
+\begin{array} { l } { - \mathbb { E } _ { x , y \sim \mathcal { L } ^ { t r } } \left[ \log p ( y | x , y \leq K ; \theta ) \right] - \mathbb { E } _ { x \sim \mathcal { U } ^ { t r } } \left[ \log \left\{ \displaystyle \sum _ { k = 1 } ^ { K } p ( k | x ; \theta ) \right\} \right] } \\ { - \mathbb { E } _ { x \sim \mathcal { D } _ { G } ( \phi ) } \left[ \log p ( K + 1 | x ; \theta ) \right] - \mathbb { E } _ { x \sim \mathcal { U } ^ { t r } } \left[ \displaystyle \sum _ { k = 1 } ^ { K } p ( k | x ; \theta ) \log p ( k | x ; \theta ) \right] } \end{array}
+$$
+
+for given $\phi$ , where $\mathcal { L } ^ { t r }$ is the labeled set. The second and the third terms in (1) are the cross-entropies between the unlabeled and the bad samples. The fourth term is similar the entropy of the unlabeled data which is usually helpful for semi-supervised learning (Grandvalet & Bengio, 2005). See Dai et al. (2017) for details of the objective function (1).
+
+# 2.2 VAT APPROACH
+
+$V A T$ is a regularization method which is inspired by the adversarial training (Goodfellow et al., 2014b). The regularization term of VAT is given as:
+
+$$
+\begin{array} { r c l } { \boldsymbol { L } ^ { \mathrm { V A T } } ( \boldsymbol { \theta } ; \widehat { \boldsymbol { \theta } } , \boldsymbol { x } , \epsilon ) } & { = } & { \displaystyle { D _ { \mathrm { K L } } } \left( p ( \cdot | \boldsymbol { x } ; \widehat { \boldsymbol { \theta } } ) | | p ( \cdot | \boldsymbol { x } + r _ { \mathrm { a d v r } } ( \boldsymbol { x } , \epsilon ) ; \boldsymbol { \theta } ) \right) } \\ & { = } & { \displaystyle - \sum _ { k = 1 } ^ { K } p ( k | \boldsymbol { x } ; \widehat { \boldsymbol { \theta } } ) \log p ( k | \boldsymbol { x } + r _ { \mathrm { a d v r } } ( \boldsymbol { x } , \epsilon ) ; \boldsymbol { \theta } ) + C , } \end{array}
+$$
+
+where
+
+$$
+r _ { \mathrm { a d v r } } ( \boldsymbol { x } , \epsilon ) = \underset { r ; | \lvert r \rvert | \le \epsilon } { \mathrm { a r g m a x } } D _ { \mathrm { K L } } \left( p ( \cdot | \boldsymbol { x } ; \widehat { \boldsymbol { \theta } } ) | | p ( \cdot | \boldsymbol { x } + r ; \widehat { \boldsymbol { \theta } } ) \right) ,
+$$
+
+$\epsilon > 0$ is a tuning parameter, $\theta$ is the parameter in the discriminator to train, $\widehat { \theta }$ is the current estimate of $\theta$ and $C$ is a constant. Combining with the cross-entropy term of the labeled data, we get the final objective function of $V A T$ :
+
+$$
+- \mathbb { E } _ { \boldsymbol { x } , \boldsymbol { y } \sim \mathcal { L } ^ { t r } } \left[ \log p ( \boldsymbol { y } | \boldsymbol { x } ; \boldsymbol { \theta } ) \right] + \mathbb { E } _ { \boldsymbol { x } \sim \mathcal { U } ^ { t r } } \left[ \boldsymbol { L } ^ { \mathrm { V A T } } ( \boldsymbol { \theta } ; \widehat { \boldsymbol { \theta } } , \boldsymbol { x } , \epsilon ) \right] .
+$$
+
+# 3 GENERATION OF BAD SAMPLES BY ADVERSARIAL TRAINING
+
+The key role of bad samples in Bad GAN is to enforce the decision boundary to be pulled toward the low density regions of the unlabeled data. To do this, bad samples must be located at the valleys of the distribution of the unlabeled data. In this section, we propose a novel technique to generate ‘good’ bad samples by use of only a given classifier.
+
+# 3.1 MOTIVATION
+
+In this subsection, we explain why the adversarial direction is toward the decision boundary. For simplicity, we only consider the linear decision boundary. For the decision boundary made by the DNN model with ReLU activation function, see Appendix A.2.
+
+Let us consider the 2-class linear logistic regression model parametrized by $\eta = \{ w , b \}$ , that is, $p ( y = 1 | x ; \eta ) = \left( 1 + \exp ( - b - w ^ { ' } x ) \right) ^ { - 1 }$ . Note that the decision boundary is $\{ x : b + w ^ { ' } x = 0 \}$ , and for any given $x$ , the distance between $x$ and the decision boundary is $| b + w ^ { ' } x | / | | w | |$ . The key
+
+![](images/5273c9df6c8b92ef502c36c1a00be0c95442c2991dc886aa558727d6656d5c25.jpg)  
+Figure 1: Demonstration of how the bad samples generated by the adversarial training are distributed. We consider two cases: 3-class classification problem (Left) and 4-class classification problem (Right). True data and bad data are coloured by blue and orange, respectively.
+
+result is that moving $x$ toward the adversarial direction $r _ { \mathrm { a d v r } } ( x , \epsilon )$ is equivalent to moving $x$ toward the decision boundary which is stated rigorously in the following proposition. The proof is in the appendix.
+
+Proposition 1 For a sufficiently small $\epsilon > 0$ , we have
+
+$$
+s i g n ( w ^ { ' } x + b ) \cdot s i g n \left( w ^ { ' } r _ { a d \nu r } ( x , \epsilon ) \right) = - 1 .
+$$
+
+Proposition 1 implies that $| b + w ^ { ' } x | / | | w | | > | b + w ^ { ' } ( x + r ^ { \mathrm { a d v r } } ( x , \epsilon ) | / | | w | |$ unless $| b + w ^ { ' } x | = 0$ . Hence, we can treat $x + \delta r _ { \mathrm { a d v r } } ( x , \epsilon ) / | | r ^ { \mathrm { a d v r } } ( x , \epsilon ) | |$ for appropriately choosing $\delta > 0$ as a bad sample (a sample closer to the decision boundary).
+
+# 3.2 BAD SAMPLE GENERATION WITH GENERAL CLASSIFIER
+
+Motivated by Proposition 1, we propose a bad sample generator as follows. Let $\delta > 0$ be fixed and $\widehat { \theta }$ be the current estimate of $\theta$ . For a given input $x$ and a classifier $p ( \cdot | x ; \widehat { \theta } )$ , we calculate the adversarial direction $r _ { \mathrm { a d v r } } ( x , \epsilon )$ for given $\epsilon$ by (2). Then, we consider $x _ { \mathrm { b a d } } = x + \delta r _ { \mathrm { a d v r } } ( x , \epsilon ) / \| r _ { \mathrm { a d v r } } ( x . \epsilon ) \|$ as a bad sample (a sample closer to the decision boundary). We generate bad samples for all unlabeled data. In practice, we apply the same $\delta$ to all unlabeled data and choose $\delta$ based on the validation data accuracy.
+
+In Figure 1, we illustrate how the bad samples generated by the proposed adversarial training are distributed for multi-class problem. With a good classifier, we can clearly see that most bad samples are located well in the low density regions of the data.
+
+It may happen that a generated bad sample is not sufficiently close to the decision boundary to be a ’good’ bad sample, in particular when $\delta$ is too large or too small. To avoid such a situation, we exclude $x _ { \mathrm { b a d } }$ which satisfies the following condition:
+
+$$
+\operatorname* { m a x } _ { k } p ( k | x _ { \mathrm { b a d } } ; \widehat { \theta } ) > 1 - \tau
+$$
+
+for a prespecified $\tau > 0$ . In our experiments, we set the optimal $\tau$ with validation data.
+
+# 4 FAST ADVERSARIAL TRAINING WITH BAD SAMPLES
+
+Once we generate bad samples by the adversarial training, $F A T$ updates $\theta$ by minimizing the following objective function:
+
+$$
+\begin{array} { r l } & { - \mathbb { E } _ { x , y \sim \mathcal { L } ^ { t r } } \left[ \log p ( y | x ; \theta ) \right] + \mathbb { E } _ { x \sim \mathcal { U } ^ { t r } } \left[ L ^ { \mathrm { t r u e } } ( \theta ; x ) \right] + \mathbb { E } _ { x \sim \mathcal { D } ^ { b a d } ( \widehat { \theta } , \epsilon , \delta ) } \left[ L ^ { \mathrm { f a k e } } ( \theta , x ) \right] } \\ & { + \mathbb { E } _ { x \sim \mathcal { U } ^ { t r } } \left[ L ^ { \mathrm { V a T } } ( \theta ; \widehat { \theta } , x , \epsilon ) \right] } \end{array}
+$$
+
+where $\mathcal { D } ^ { b a d } ( \widehat { \theta } , \epsilon , \delta )$ is the set of generated bad samples with ${ \widehat { \theta } } , \epsilon$ and $\delta$ ,
+
+$$
+\begin{array} { l } { { { \cal L } ^ { \mathrm { t r u e } } } ( \theta ; x ) = - \displaystyle \sum _ { k = 1 } ^ { K } \left[ \displaystyle \frac { \exp ( g _ { k } ( x ; \theta ) ) } { 1 + \sum _ { k ^ { \prime } = 1 } ^ { K } \exp ( g _ { k ^ { \prime } } ( x ; \theta ) ) } \log \displaystyle \frac { \exp ( g _ { k } ( x ; \theta ) ) } { 1 + \sum _ { k ^ { \prime } = 1 } ^ { K } \exp ( g _ { k ^ { \prime } } ( x ; \theta ) ) } \right] , } \\ { { { \cal L } ^ { \mathrm { f a k e } } } ( \theta ; x ) = - \log \displaystyle \frac { 1 } { 1 + \sum _ { k = 1 } ^ { K } \exp ( g _ { k } ( x ; \theta ) ) } , } \end{array}
+$$
+
+$g ( x ; \theta ) \in \mathbb { R } ^ { K }$ is a pre-softmax vector of a given deep architecture and $\lambda > 0$ . We treat $\epsilon$ and $\delta$ as tuning parameters to be selected based on the validation data accuracy. We minimize the objective function with one of the standard optimization algorithms such as Adam (Kingma & Ba, 2014) or RMSProp (Tieleman & Hinton, 2012).
+
+The objective function (5) differs from the objective function (1) of Bad GAN in a way that the second term of (1), the cross-entropy of not being a bad sample, is deleted and the regularization term of VAT is added. We delete the second term of (1) because it can be easily shown that a perfect classifier of unlabeled data can be obtained from the minimizer of the objective function (1) without the second term under the conditions in Dai et al. (2017). The regularization term of VAT is added to improve the bad sample generator based on adversarial training. See Section 5.1 for detailed discussions.
+
+Miyato et al. (2017) proposes the fast approximation method to calculate the adversarial direction $r _ { \mathrm { a d v r } } ( x , \epsilon )$ by using the second-order Taylor expansion. Let us define $H ( x , { \widehat { \theta } } ) \ =$ $\nabla \nabla D _ { \mathrm { K L } } \left( p ( \cdot | x ; \widehat { \theta } ) | | p ( \cdot | x + r ; \widehat { \theta } ) \right) | _ { r = 0 }$ . They claim that $r _ { \mathrm { a d v r } }$ emerges as the first dominant eigenvector $u ( x , \widehat { \theta } )$ of $H ( x , { \widehat { \theta } } )$ with magnitude $\epsilon$ . But there always exist two dominant eigenvectors, $\pm u ( x , \widehat { \theta } )$ , and the sign should be selected carefully. So, we slightly modify the approximation method of Miyato et al. (2017) by
+
+$$
+r _ { \mathrm { a d v r } } ( \boldsymbol { x } , \epsilon ) = \operatorname * { a r g m a x } _ { \boldsymbol { r } \in \{ \boldsymbol { u } ( \boldsymbol { x } , \widehat { \boldsymbol { \theta } } ) , - \boldsymbol { u } ( \boldsymbol { x } , \widehat { \boldsymbol { \theta } } ) \} } D _ { \mathrm { K L } } \left( p ( \cdot | \boldsymbol { x } ; \widehat { \boldsymbol { \theta } } ) | | p ( \cdot | \boldsymbol { x } + \boldsymbol { r } ; \widehat { \boldsymbol { \theta } } ) \right) .
+$$
+
+This modification helps to improve convergence speed of the test accuracy, which will be demonstrated in the ablation experiments.
+
+# 5 ROLE OF VAT FOR SEMI-SUPERVISED LEARNING
+
+In this section, we investigate the roles of the regularization term of VAT in our method in detail. First, we verify that VAT regularization term does help to generate ’better’ bad samples with a simple experiment. Furthermore, we give a theoretical insight for the role of the regularization term of VAT in semi-supervised learning. We will show that the regularization term of VAT pushes the decision boundary from the high density regions of unlabeled data. As a result, FAT uses pushing operations by VAT term as well as pulling operations by bad samples simultaneously, which makes it possible to accelerate the training process with improved performances.
+
+# 5.1 IMPROVEMENT OF BAD SAMPLES WITH VAT
+
+For generated samples by adversarial training to be ‘good’ bad samples, the adversarial directions should be toward the decision boundary. While this always happens for the linear model by Proposition 1, adversarial directions could be opposite to the decision boundary for deep model. To avoid such undesirable cases as much as possible, it would be helpful to smoothen the classifier with a regularization term. In this section, we explain that the regularization term of VAT plays such a role.
+
+The adversarial direction obtained by maximizing the KL divergence is sensitive to local fluctuations of the class probabilities which is examplified in Figure 2. The regularization term of VAT is helpful to find a right adversarial direction which is toward the decision boundary by eliminating unnecessary local fluctuations of the class probabilities. In Figure 3, we compare bad samples generated by the adversarial training with and without the regularization term of VAT for the MNIST dataset. While the bad samples generated without the regularization term of VAT are visually similar to the given input vectors, the bad samples generated with the regularization term of VAT look like mixtures of two different digits and thus serve as ‘better’ bad samples.
+
+![](images/fc2a84b1323bfadcad3728fdd6481dc3bbfdadf75ab76068137bb03e5b8f60b7.jpg)  
+Figure 2: Examples of $P ( y = 1 | x )$ of smooth (Left) and wiggle (Right) cases. We plot 3 points and their adversarial directions on each case.
+
+![](images/d07d00333c8809877229d2a92f62af0d604669ecd48bb36d5a743a2235671f26.jpg)  
+Figure 3: (Upper) 10 randomly sampled original MNIST dataset. (Middle and Lower) Bad samples obtained by the classifier learned with and without the regularization term of VAT.
+
+# 5.2 THEORETICAL ANALYSIS OF VAT
+
+Suppose that $\mathcal { X }$ is partitioned by $( K + 1 )$ mutually disjoint subsets $\mathcal { X } _ { k }$ for $k = 1 , \ldots , K + 1$ such that $y ( x ) = k$ for all $x \in { \mathcal { X } } _ { k } , k \leq K$ and $p ^ { * } ( x ) = 0$ for $x \in \mathcal { X } _ { K + 1 }$ , where $y ( x )$ is the ground-truth label of $x$ and $p ^ { * } ( x )$ is the true density of $x$ . For a given feature map $u : \mathcal { X }  \mathbb { R } ^ { m }$ and weight vectors $w _ { 1 } , \ldots , w _ { k }$ , let $p ( y = k | x ) \propto \exp ( w _ { k } ^ { ' } u ( x ) )$ for $k = 1 , \ldots , K$ and $p ( y = K + 1 | x ) \propto 1$ . Let $\mathcal { L } ^ { t r }$ satisfy $\mathcal { X } _ { k } \cap \mathcal { L } _ { t r } \neq \emptyset$ for $k = 1 , . . . K$ . Suppose that (i) $\ \mathrm { a r g m a x } _ { h } p ( y = h | x ) = y$ for $\boldsymbol { x } \in \mathcal { L } _ { t r }$ , (ii) $\mathrm { a r g m a x } _ { h } p ( y = h | x ) \le K$ for $x \in \cup _ { k = 1 } ^ { K } \mathcal { X } _ { k }$ and (iii) argmax $\dot { \mathbf { \rho } } _ { h } p ( y = h | x ) = K + 1$ for $x \in \mathcal { X } _ { K + 1 }$ . Under these three conditions, Dai et al. (2017) proves that $\mathrm { a r g m a x } _ { h } p ( y = h | x ) = y ( x )$ for all $x \in \cup _ { k = 1 } ^ { K } \mathcal { X } _ { k }$ . That is, generating large ‘good’ bad samples is helpful for classifying unlabeled data correctly only with a small amount of labeled data.
+
+A similar result can be obtained for VAT objective function itself under mild additional conditions. For given two subsets $\mathcal { A } _ { 1 }$ and $\boldsymbol { A } _ { 2 }$ of $\mathcal { X }$ , we define $\begin{array} { r } { d ( A _ { 1 } , A _ { 2 } ) = \operatorname* { m i n } _ { x _ { 1 } \in A _ { 1 } , x _ { 2 } \in A _ { 2 } } d ( x _ { 1 } , x _ { 2 } ) } \end{array}$ for a given metric $d$ . We define a tuple $( x , x ^ { ' } )$ is $\epsilon$ -connected if $d ( x , x ^ { ' } ) < \epsilon$ . A finite subset $\mathcal { A }$ of $\mathcal { X }$ is called $\epsilon$ -connected iff for all $x , x ^ { ' } \in { \mathcal { A } }$ , there exists a finite path $( x , x _ { 1 } , . . . , x _ { q } , x ^ { ' } )$ such that $x _ { j } \in { \mathcal { A } }$ for $j = 1 , \dotsc , q$ an $1 ( x , x _ { 1 } ) , ( x _ { 1 } , x _ { 2 } ) , . . . , ( x _ { q - 1 } , x _ { q } ) , ( x _ { q } , x ^ { ' } )$ are all $\epsilon$ -connected.
+
+Proposition 2 Assume that there exists $\epsilon > 0$ such that $\pmb { I }$ ) $\mathcal { U } _ { k } ^ { t r } = \mathcal { U } ^ { t r } \cap \mathcal { X } _ { k } , k = 1 , \ldots , K$ are $\epsilon$ -connected, 2) $d ( \mathcal { X } _ { k } , \mathcal { X } _ { k ^ { \prime } } ) \geq 2 \epsilon$ for all $k \neq k ^ { ' } \leq K$ , and 3) for each $k \leq K$ , there exists at least one $( x , k ) \in \mathcal { L } ^ { t r }$ such that $d ( \{ x \} , \mathcal { U } _ { k } ^ { t r } ) < \epsilon$ . Suppose that there exists a classifier $f : \mathcal { X } \to \{ 1 , . . . , K \}$ such that $f ( x ) = y$ for all $( x , y ) \in \mathcal { L } ^ { t r }$ and
+
+$$
+f ( x ) = f ( x ^ { ' } ) f o r a l l x ^ { ' } \in \mathcal { B } ( x , \epsilon )
+$$
+
+for all $\boldsymbol { x } \in \boldsymbol { U } ^ { t r }$ , where $\displaystyle B ( x , \epsilon ) = \{ x ^ { \prime } : d ( x , x ^ { \prime } ) \leq \epsilon \}$ . Then, the function $f$ classifies the unlabeled set perfectly, that is:
+
+$$
+f ( x ) = y ( x ) f o r a l l x \in \mathcal { U } ^ { t r } .
+$$
+
+Condition 1) and 2) mean that the unlabeled data are dense enough and the supports of each class are separated sufficiently, respectively. Condition 3) assumes that at least one labeled instance exists near the supports of each class. The main condition of Proposition 2 is (6) which essentially assumes that the classifier $f$ does not change much locally. That is, $f$ is invariant with respect to all small perturbations of an input $x$ . Note that the regularization term of $V A T$ is devised to improve the invariancy of the classifier and Proposition 2 explains why improving the invariancy is helpful for semi-supervised learning.
+
+# 5.3 INTERPRETATION OF VAT
+
+Let $f ( x ; \theta ) = \mathrm { a r g m a x } _ { h } p ( y = h | x ; \theta )$ . Proposition 2 implies that it would be good to pursue a classifier which predicts the labeled data correctly and at the same time is invariant with respect to all local perturbations on the unlabeled data. For this purpose, a plausible candidate of the objective function is
+
+$$
+\begin{array} { r } { \mathbb { E } _ { ( { x } , { y } ) \sim \mathcal { L } ^ { t r } } \left[ \mathbb { I } ( { y } \neq f ( { x } ; { \theta } ) \right] + \mathbb { E } _ { { x } \sim \mathcal { U } ^ { t r } } \left[ \mathbb { I } \left( f ( { x } ; { \theta } ) \neq f ( { x } ^ { ' } ; { \theta } ) \mathrm { ~ f o r ~ } { \forall x } ^ { ' } \in \mathcal { B } ( { x } , { \epsilon } ) \right) \right] . } \end{array}
+$$
+
+Note that a classifier $f$ which achieves 0 value of the objective function (7) satisfies the conditions of Proposition 2 and thus classifies all unlabeled data correctly.
+
+The objective function (7) is not practically usable since neither optimizing the indicator function nor checking $f ( x ; \theta ) \neq f ( x ^ { ' } ; \theta )$ for all $x ^ { ' }$ in $B ( x , \epsilon )$ is possible. To resolve these problems, we replace the indicator functions in (7) with the cross-entropies, and the neighborhood $B ( x , \epsilon )$ in the second term with the adversarial direction. By doing so, we have the following alternative objective function:
+
+$$
+- \mathbb { E } _ { x , y \sim \mathcal { L } ^ { t r } } \left[ \log p ( y | x ; \theta ) \right] - \mathbb { E } _ { x \sim \mathcal { U } ^ { t r } } \left[ \sum _ { k = 1 } ^ { K } p ( k | x ; \theta ) \log p ( k | x + r _ { \mathrm { a d v r } } ( x , \epsilon ) ; \theta ) \right] .
+$$
+
+Finally, we replace $p ( \cdot | x ; \theta )$ in the second term of (8) by $p ( \cdot | x ; \widehat { \theta } )$ to have the objective function of VAT (3).
+
+The condition (6) in Proposition 2 means that the decision boundary is not located inside the support $\mathcal { X } _ { k }$ of each class. That is, the regularization term of VAT prevents the decision boundary from being located at the high density regions of data or equivalently pushes the decision boundary from the high density regions of data.
+
+# 6 EXPERIMENTS
+
+# 6.1 PREDICTION PERFORMANCES IN SEMI-SUPERVISED LEARNING
+
+We compare prediction performances of $F A T$ over the benchmark datasets with other semi-supervised learning algorithms. We consider the most widely used datasets: MNIST (LeCun et al., 1998), SVHN (Marlin et al., 2010) and CIFAR10 (Krizhevsky & Hinton, 2009). As in done by other works, we randomly sample 100, 1000 and 4000 labeled data from the MNIST, SVHN and CIFAR10 datasets, respectively and use them as the labeled data and the rest as the unlabeled data. For fair comparison, we use the same architectures as those used in Miyato et al. (2017) for MNIST, SVHN and CIFAR10. The optimal tuning parameters $( \epsilon , \tau , \delta )$ in $F A T$ are chosen based on the validation data accuracy.
+
+Table 1: Comparison of prediction accuracies of various semi-supervised learning algorithms for the three benchmark datasets. mod. VAT is the modified version of VAT stated in Section 4.   
+
+<table><tr><td>Method</td><td colspan="3">Test acc.(%)</td></tr><tr><td></td><td>MNIST(100)</td><td>SVHN(1000)</td><td>CIFAR10(4000)</td></tr><tr><td>DGN (Kingma et al., 2014)</td><td>96.67</td><td>63.98</td><td>-</td></tr><tr><td>Ladder (Rasmus et al., 2015)</td><td>98.94</td><td>1</td><td>79.6</td></tr><tr><td>ALI (Donahue et al., 2016)</td><td>1</td><td>92.58</td><td>82.01</td></tr><tr><td>FM-GAN (Salimans et al.,2016)</td><td>99.07</td><td>91.89</td><td>81.37</td></tr><tr><td>FM-GAN-Tan (Kumar et al., 2017)</td><td>1</td><td>95.61</td><td>83.80</td></tr><tr><td>Bad GAN (Dai et al., 2017)</td><td>99.20</td><td>95.75</td><td>85.59</td></tr><tr><td>VAT (Miyato et al., 2017)</td><td>98.64</td><td>93.17</td><td>85.13</td></tr><tr><td>CrossEnt (use all data)</td><td>98.82</td><td>96.74</td><td>90.31</td></tr><tr><td>CrossEnt (use lab. data only)</td><td>79.16</td><td>88.91</td><td>67.45</td></tr><tr><td>mod. VAT</td><td>98.70</td><td>94.69</td><td>85.18</td></tr><tr><td>FAT</td><td>98.89</td><td>95.94</td><td>85.31</td></tr></table>
+
+Table 2: Comparison of prediction accuracies with small labeled data and more complex dataset.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="4">Test acc.(%)</td></tr><tr><td>MNIST(20)</td><td>SVHN(500)</td><td>CIFAR10(1000)</td><td>CIFAR100(8000)</td></tr><tr><td>FM-GAN (Salimans et al., 2016)</td><td>83.23</td><td>81.56</td><td>78.13</td><td>-</td></tr><tr><td>FM-GAN-Tan (Salimans et al., 2016)</td><td>-</td><td>95.13</td><td>80.48</td><td>1</td></tr><tr><td>CrossEnt(use all data)</td><td>98.82</td><td>96.74</td><td>90.31</td><td>46.72</td></tr><tr><td>CrossEnt(use lab.data only)</td><td>54.92</td><td>85.82</td><td>50.30</td><td>18.35</td></tr><tr><td>mod. VAT</td><td>89.92</td><td>92.59</td><td>75.43</td><td>34.76</td></tr><tr><td>FAT</td><td>96.32</td><td>95.21</td><td>75.96</td><td>35.52</td></tr></table>
+
+We use Adam algorithm (Kingma & Ba, 2014) to update the parameters and do not use any data augmentation techniques. The results are summarized in Table 1, which shows that $F A T$ achieves the state-of-the-art accuracy for SVHN dataset and competitive accuracies with the state-of-the-art method (i.e. Bad GAN) for MNIST and CIFAR10.
+
+We conduct another experiments where the numbers of labeled data are much smaller and consider a more complex dataset CIFAR100 (Krizhevsky & Hinton, 2009), whose results are summarized in Table 2. Note that FAT still dominates mod. VAT for the all datasets and the margins become larger. While $F A T$ achieves the state-of-the-art performances for MNIST and SVHN, its performance degrades much for CIFAR10 compared to the accuracy for the case of 4000 labeled data. Note that the quality of bad samples depends on the quality of the estimated classifier. For CIFAR10 which is relatively more complex than MNIST and SVHN, the quality of the estimated classifier is influenced much to the amount of labeled data and thus the accuracy of $F A T$ is more sensitive to the amount of labeled data. However, it is interesting to see that $F A T$ is superior to mod. VAT for CIFAR10 and CIFAR100, which suggests that bad samples are helpful for complex problems where the quality of bad samples might not be sufficiently good.
+
+The other advantage of $F A T$ is its stability with respect to learning phase. With small labeled data, the test accuracies of each epoch tends to fluctuate much for VAT and mod VAT, while $F A T$ provides much more stable results. See Figure 7 in Appendix. This may be partly because ’good’ bad samples keep the classifier from fluctuation.
+
+Table 3: Test accuracies of MNIST for various values of $\tau$ and $\delta$ . The other two parameters on each case are fixed to the optimal values.   
+
+<table><tr><td>T</td><td>0.001</td><td>0.01</td><td>0.1</td><td>0.2</td></tr><tr><td>Test acc.</td><td>98.65</td><td>98.89</td><td>98.77</td><td>98.71</td></tr></table>
+
+<table><tr><td>8</td><td>1</td><td>2.</td><td>4.</td><td>6.</td></tr><tr><td>Test acc.</td><td>89.54</td><td>98.89</td><td>98.79</td><td>98.55</td></tr></table>
+
+Table 4: Test accuracies for diverse objective loss functions.   
+
+<table><tr><td>Data Setting</td><td>MNIST</td><td>SVHN</td><td>CIFAR10</td></tr><tr><td>Ltrue +Lfake +LVAT</td><td>98.89</td><td>Test acc.(%) 95.94</td><td>85.15</td></tr><tr><td>Ltrue +Lfake</td><td>83.6</td><td>90.21</td><td>68.32</td></tr><tr><td>Lfake+ LVAT</td><td>98.77</td><td>95.71</td><td>85.31</td></tr></table>
+
+# 6.2 EFFECTS OF TUNING PARAMETERS
+
+$F A T$ introduces two additional tuning parameters $\tau$ and $\delta$ compared to VAT, where $\tau$ is used to determine whether a bad sample is ’good’ and $\delta$ is the radius to generate bad samples. We investigate the sensitivities of prediction performances with respect to the changes of the values of $\tau$ and $\delta$ with $\epsilon$ being fixed at 1.5 that is the optimal value. The results are reported in Table 3. Unless $\tau$ is too small or too large, the prediction performances are not changed much. For $\delta$ , care should be done. Too small $\delta$ , smaller than , hampers the prediction performance much. Apparently, a similar value of $\delta$ to that of $\epsilon$ (i.e. $\delta = 2$ ) gives the best result.
+
+# 6.3 OBJECTIVE FUNCTION ANALYSIS
+
+In this subsection, we analyze the effects of $L ^ { \mathrm { t r u e } }$ and $L ^ { \mathrm { V A T } }$ in this section. We do not consider the cross-entropy of the labeled data and $L ^ { \mathrm { f a k e } }$ since they are necessary to reflect the idea utilizing bad data. Table 4 compares the performances without one or both of these terms. Note that $L ^ { \mathrm { V A T } }$ is necessary for superior performances, which is because $L ^ { \mathrm { V A T } }$ is indispensable to generate ‘good’ bad samples as explained in Section 5.1. On the other hand, the term $L ^ { \mathrm { t r u e } }$ , which is devised to separate unlabeled data from bad samples, is not always helpful. A possible explanation is that sometimes the term $L ^ { \mathrm { t r u e } }$ would give an undesirable effect on the misclassified data.
+
+# 6.4 COMPUTATIONAL EFFICIENCY
+
+We investigate the computational efficiency of our method in view of learning speed and computation time per training epoch. For Bad GAN, we did not use $P i x e l C N N { + + }$ on SVHN and CIFAR10 datasets since the pre-trained $P i x e l C N N { + + }$ models are not publicly available. Figure 4 draws the bar plots about the numbers of epochs needed to achieve the prespecified test accuracies. We can clearly see that $F A T$ requires much less epochs
+
+We also calculate the ratios of the computing time of each semi-supervised learning algorithm over the computing time of the corresponding supervised learning algorithm for CIFAR10 dataset, whose results are summarized in Table 5. These ratios are almost same for different datasets. The computation time of $F A T$ is competitive to VAT and mod. VAT, and hence we can conclude that $F A T$ arrives at the prespecified performances much efficiently. Note that $P i x e l C N N { + + }$ is not used for this experiment, and so comparison of computing time of $F A T$ and Bad GAN with $P i x e l C N N + +$ is meaningless
+
+![](images/4a65d8b5b70ee0c028d73f8d35c14f7ed23be19f1820366a082249f31828e737.jpg)  
+Figure 4: The number of epochs to achieve the prespecified test accuracies $9 8 \%$ , $90 \%$ and $80 \%$ ) with the four methods for (Left) MNIST, (Middle) SVHN and (Right) CIFAR10 datasets. Bad $G A N$ is operated without $P i x e l C N N + +$ for SVHN and CIFAR10 datasets.
+
+Table 5: Learning time per training epoch ratios compared to supervised learning with cross-entropy for CIFAR10. Bad GAN is operated without $P i x e l C N N + +$ .   
+
+<table><tr><td>Method</td><td>VAT</td><td>mod. VAT</td><td>FAT</td><td>Bad GAN</td></tr><tr><td>Time ratio</td><td>1.37</td><td>1.62</td><td>2.09</td><td>3.20</td></tr></table>
+
+# 6.5 QUALITY OF BAD SAMPLES GENERATED BY ADVERSARIAL TRAINING
+
+We investigate how ‘good’ bad samples generated by the adversarial training are. The upper panel of Figure 5 shows the scatter plot of the synthetic data and the trace plot of prediction accuracies of $F A T$ and VAT. And the lower panel of Figure 5 draws the scatter plots with generated bad samples at various epochs. We can clearly see that bad samples move to lower density regions as the epoch increases, which amply demonstrates that the adversarial training is good at generating bad samples. We also compare bad images of the MNIST data generated by $F A T$ and Bad GAN in Figure 6. The bad images by $F A T$ do not look like real images and do not seem to be collapsed, which indicates that $F A T$ consistently generates diverse and good bad samples. Bad GAN also generates diverse bad samples but some ‘realistic’ images can be found.
+
+# 7 CONCLUSION
+
+In this paper, we propose a new method called FAT for semi-supervised learning which generates bad samples only with a given classifier. The objective function of $F A T$ is devised to compromise the advantages of Bad GAN and VAT together, which makes $F A T$ be faster and more accurate. In numerical experiments, we show that $F A T$ achieves almost the state-of-the-art performances with much fewer epochs. Unlike Bad GAN , $F A T$ only needs to learn a discriminator. Hence, it could be extended without much effort to other learning problems. For example, $F A T$ can be modified easily for recurrent neural networks and hence can be applied to sequential data. We will leave this extension as a future work.
+
+It would be useful to combine $F A T$ with a generative approach such as Bad GAN, in particular when the initial classifier is bad. Since FAT uses only a classifier to generate bad samples, the initial estimate of the classifier would be important. Using the generator model learned by large unlabeled data would be helpful to find a good initial estimate of the classifier.
+
+# ACKNOWLEDGMENTS
+
+This work is supported by Samsung Electronics Co., Ltd.
+
+![](images/911fdbc2dd3e183753ca3d8c54938f735c0cd0ea5edd11ed47ada3b801239e24.jpg)  
+Figure 5: (Upper Left) The scatter plot of synthetic data which consist of 1000 unlabeled data (gray) and 4 labeled data for each class (red and blue with black edge). (Upper Right) Accuracies of unlabeled data for each epochs for VAT and FAT. We use 2-layered NN with 100 hidden units each. (Lower) Bad samples and classified unlabeled data by colors at the different training epochs of FAT
+
+![](images/518422245968365df9605efa288ca84be63a6bea1214a3f5fc3d22a49c2d6611.jpg)  
+Figure 6: 100 randomly sampled bad images using (Left) FAT and (Right) Bad GAN.
+
+# REFERENCES
+
+Zihang Dai, Zhilin Yang, Fan Yang, William W Cohen, and Ruslan R Salakhutdinov. Good semisupervised learning that requires a bad gan. In Advances in Neural Information Processing Systems, pp. 6513–6523, 2017.
+
+Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014a.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014b.
+
+Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Advances in neural information processing systems, pp. 529–536, 2005.
+
+Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik $\mathrm { \bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Diederik P Kingma, Shakir Mohamed, Danilo Jimenez Rezende, and Max Welling. Semi-supervised learning with deep generative models. In Advances in Neural Information Processing Systems, pp. 3581–3589, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Abhishek Kumar, Prasanna Sattigeri, and Tom Fletcher. Semi-supervised learning with gans: manifold invariance with improved inference. In Advances in Neural Information Processing Systems, pp. 5534–5544, 2017.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Lars Maaløe, Casper Kaae Sønderby, Søren Kaae Sønderby, and Ole Winther. Auxiliary deep generative models. arXiv preprint arXiv:1602.05473, 2016.
+
+Benjamin Marlin, Kevin Swersky, Bo Chen, and Nando Freitas. Inductive principles for restricted boltzmann machine learning. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pp. 509–516, 2010.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional smoothing with virtual adversarial training. arXiv preprint arXiv:1507.00677, 2015.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. arXiv preprint arXiv:1704.03976, 2017.
+
+Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semi-supervised learning with ladder networks. In Advances in Neural Information Processing Systems, pp. 3546– 3554, 2015.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016.
+
+Tim Salimans, Andrej Karpathy, Xi Chen, and Diederik P Kingma. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. arXiv preprint arXiv:1701.05517, 2017.
+
+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.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26–31, 2012.
+
+Jason Weston, Frédéric Ratle, Hossein Mobahi, and Ronan Collobert. Deep learning via semisupervised embedding. In Neural Networks: Tricks of the Trade, pp. 639–655. Springer, 2012.
+
+# A APPENDIX
+
+# A.1 PROOF OF PROPOSITION 1
+
+Without loss of generality, we assume that $w ^ { ' } x + b > 0$ , that is, $p ( y = 1 | x ; \eta ) > p ( y = 0 | x ; \eta )$ . We will show that there exists $\epsilon > 0$ such that $w ^ { ' } r ^ { * } ( x , \epsilon ) < 0$ . Note that
+
+$$
+\begin{array} { r l r } {  { \operatorname * { a r g m a x } _ { \begin{array} { l } { r , | | x | | \leq \epsilon , w ^ { \prime } r > 0 } \\ { \operatorname * { a r g m a x } _ { \begin{array} { l } { K L ( x , r ; \eta ) = - \epsilon } \\ { r , | | w | | \leq \epsilon , w ^ { \prime } r < 0 } \end{array} } } \textstyle K L ( x , r ; \eta ) = \epsilon \frac { w } { | | w | | } ( = : r _ { 1 } ^ { * } ) \quad \mathrm { a n d } } } \end{array} }  \\ & { } &  \operatorname * { a r g m a x } _ { \begin{array} { l } { K L ( x , r ; \eta ) = - \epsilon \frac { w } { | | w | | } ( = : r _ { 2 } ^ { * } ) . } \end{array} } \end{array}
+$$
+
+So all we have to do is to show
+
+$$
+K L ( x , r _ { 2 } ^ { * } ; \eta ) > K L ( x , r _ { 1 } ^ { * } ; \eta ) .
+$$
+
+By simple calculation we can get the following:
+
+$$
+\small \begin{array} { r } { \nabla L ( x , r _ { 2 } ^ { * } ; \eta ) - K L ( x , r _ { 1 } ^ { * } ; \eta ) = - \left[ p ( y = 1 | x ; \theta ) w ^ { ' } ( r _ { 2 } ^ { * } - r _ { 1 } ^ { * } ) - \log \frac { \exp \big ( w ^ { ' } ( x + r _ { 2 } ^ { * } ) + b \big ) + 1 } { \exp ( w ^ { ' } ( x + r _ { 1 } ^ { * } ) + b ) + 1 } \right] . } \end{array}
+$$
+
+Using the Taylor’s expansion up to the third-order, we obtain the following:
+
+$$
+\begin{array} { r c l } { \log \Big [ \exp \Big ( w ^ { ' } ( x + r ) + b \Big ) + 1 \Big ] } & { = } & { \log \Big [ \exp \Big ( w ^ { ' } x + b \Big ) + 1 \Big ] + p ( y = 1 | x ; \eta ) w ^ { ' } r } \\ & & { } & { + \displaystyle \frac { 1 } { 2 } p ( y = 1 | x ; \eta ) p ( y = 0 | x ; \eta ) r ^ { ' } w w ^ { ' } r } \\ & & { } & { - \displaystyle \frac { 1 } { 6 } p ( y = 1 | x ; \eta ) p ( y = 0 | x ; \eta ) \left\{ p ( y = 1 | x ; \eta ) - p ( y = 0 | x ; \eta ) \right. } \\ & & { } & { \left. + o ( | | r | | ^ { 3 } ) . \right. } \end{array}
+$$
+
+So,
+
+$$
+\begin{array} { r c l } { \frac { \ d s ^ { \prime } ( x + r _ { 2 } ^ { \ast } ) + \ d b \Big ) + 1 } { \ d y ^ { \prime } ( x + r _ { 1 } ^ { \ast } ) + \ d b ) + 1 } } & { = } & { p ( y = 1 | x ; \eta ) w ^ { ' } ( r _ { 2 } ^ { \ast } - r _ { 1 } ^ { \ast } ) } \\ & & { + \frac { 1 } { 3 } p ( y = 1 | x ; \eta ) p ( y = 0 | x ; \eta ) \left\{ p ( y = 1 | x ; \eta ) - p ( y = 0 | x ; \eta ) \right\} \epsilon ^ { 3 } | | w | | ^ { 3 } . } \end{array}
+$$
+
+Thus, we have the following equations:
+
+$$
+\begin{array} { r c l } { \check { \operatorname { \tiny { C } } } L ( x , r _ { 2 } ^ { * } ; \eta ) - K L ( x , r _ { 1 } ^ { * } ; \eta ) } & { = } & { \frac { 1 } { 3 } p ( y = 1 | x ; \eta ) p ( y = 0 | x ; \eta ) \left\{ p ( y = 1 | x ; \eta ) - p ( y = 0 | x ; \eta ) \right\} \epsilon ^ { 3 } } \\ & & { = } & { C \cdot \epsilon ^ { 3 } + o ( \epsilon ^ { 3 } ) . } \end{array}
+$$
+
+Therefore, there exists $\epsilon ^ { * } > 0$ such that $K L ( x , r _ { 2 } ^ { * } ; \eta ) > K L ( x , r _ { 1 } ^ { * } ; \eta )$ for $\forall 0 < \epsilon < \epsilon ^ { * }$ . 
+
+# A.2 EXTENSION OF PROPOSITION 1 FOR THE DNN CLASSIFIER
+
+Consider a binary classification DNN model with ReLU activation function $p ( y = 1 | x ; \theta ) ~ =$ $( 1 + \exp ( - g ( x ; \theta ) ) ) ^ { - 1 }$ parameterized by $\theta$ . Since $g ( x ; \theta )$ is piecewise linear, we can write $g ( \cdot ; \theta )$ as
+
+$$
+g ( \cdot ; \theta ) = \sum _ { j = 1 } ^ { N } \mathbb { I } ( \cdot \in \mathcal { A } _ { j } ) \cdot ( w _ { j } x + b _ { j } ) ,
+$$
+
+where $A _ { j }$ is a linear region and $N$ is the number of linear regions.
+
+For given $x$ , suppose $g ( x ; \theta ) > 0$ . If $g ( x : \theta )$ is estimated reasonably, we expect that $g ( x ; \theta )$ is decreasing if $x$ moves toward the decision boundary. A formal statement of this expectation would be that $x - r \nabla _ { x } g ( x ; \theta )$ can arrive at the decision boundary for a finite value of $r > 0$ , where $\nabla _ { x }$ is the gradient with respect to $x$ . Of course, for $x$ with $g ( x ; \theta ) < 0$ , we expect that $x + r \nabla _ { x } g ( x ; \theta )$ can arrive at the decision boundary for a finite value of $r > 0$ . We say that $x$ is normal if there is $r > 0$ such that $x - r \nabla _ { x } g ( x : \theta ) \mathrm { s i g n } \{ g ( x : \theta ) \}$ locates at the decision boundary. We say that a linear region $A _ { j }$ is normal if all $x$ in $A _ { j }$ are normal. We expect that most of $A _ { j }$ are normal if $g ( x ; \theta )$ is reasonably estimated so that the probability decreases or increases depending on $\operatorname { s i g n } \{ g ( x : \theta ) \}$ if $x$ is getting closer to the decision boundary.
+
+The following proposition proves that the adversarial direction is toward the decision boundary for all xs in normal linear regions.
+
+Proposition 3 If a linear region $A _ { j }$ is normal. Then for any $x \in i n t ( \mathcal { A } _ { j } )$ , there exists $\epsilon > 0$ and $\delta > 0$ such that $x _ { b a d } = x + \delta r _ { a d \nu r } ( x , \epsilon ) / | | r _ { a d \nu r } ( x , \epsilon ) | |$ is on the decision boundary.
+
+Proof. Take $\tilde { \epsilon } > 0$ such that $\boldsymbol { x } + \boldsymbol { r } \in \mathcal { A } _ { \tilde { \boldsymbol { j } } }$ for $\forall r \in B ( x , \tilde { \epsilon } )$ . Then by Proposition 1, there exists $0 < \epsilon ^ { * } < \tilde { \epsilon }$ such that for $\forall 0 < \epsilon < \epsilon ^ { * }$ ,
+
+$$
+\begin{array} { r c l } { r _ { \mathrm { a d v r } } ( \boldsymbol { x } , \epsilon ) } & { = } & { \epsilon \cdot \mathrm { s i g n } ( - b _ { \tilde { j } } - w _ { \tilde { j } } ^ { ' } x ) ) \cdot \frac { w _ { \tilde { j } } } { | | w _ { \tilde { j } } | | } } \\ & { \propto } & { - \nabla _ { x } g ( x ; \theta ) \mathrm { s i g n } \{ g ( x : \theta ) \} . } \end{array}
+$$
+
+$x$ is normal, thus there exists $\delta > 0$ such that $x _ { \mathrm { b a d } } = x + \delta r _ { \mathrm { a d v r } } ( x , \epsilon ) / | | r _ { \mathrm { a d v r } } ( x , \epsilon ) | |$ belongs to the decision boundary. 
+
+# A.3 PROOF OF PROPOSITION 2
+
+It suffices to show that $\forall x , x ^ { ' } \in \mathcal { U } _ { k } ^ { t r } , f ( x ) = f ( x ^ { ' } )$ for all $k = 1 , . . . , K$ . For given $\mathcal { U } _ { k } ^ { t r }$ , there exists $( \tilde { x } , \tilde { y } ) \in \mathcal { L } ^ { t r }$ such that $d ( \{ \tilde { x } \} , \mathcal { U } _ { k } ^ { t r } ) < \epsilon$ . So ${ \mathcal { U } } _ { k } ^ { t r } \cup \{ { \tilde { x } } \}$ is $\epsilon$ -connected. That is, for any $x \in \mathcal { U } _ { k } ^ { t r }$ , there exists a path $( \tilde { x } , x _ { 1 } , . . . , x _ { q } , x )$ such that $( \tilde { x } , x _ { 1 } ) , . . . , ( x _ { q } , x )$ are all $\epsilon$ -connected. Therefore $y ( x ) = y ( \tilde { x } ) = \tilde { y }$ for $\forall x \in \mathcal { U } _ { k } ^ { t r }$ , and the proof is done. 
+
+A.4 FIGURE
+
+![](images/6ce452a1c9709c09910e96f7d3597906a34147eb69b85bfd3aa25020a9ebafd2.jpg)  
+Figure 7: Trace plot of the test accuracies with the four methods for MNIST dataset. 20 randomly sampled data are used as the labeled data and the rest are used as the unlabeled data.

parse/train/H1fsUiRcKQ/H1fsUiRcKQ_content_list.json

@@ -0,0 +1,1922 @@
+[
+    {
+        "type": "text",
+        "text": "FAST ADVERSARIAL TRAINING FOR SEMI-SUPERVISEDLEARNING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            823,
+            151
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors ",
+        "bbox": [
+            184,
+            175,
+            326,
+            189
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Paper under double-blind review ",
+        "bbox": [
+            184,
+            193,
+            398,
+            205
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            246,
+            544,
+            261
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In semi-supervised learning, Bad GAN approach is one of the most attractive method due to the intuitional simplicity and powerful performances. Bad GAN learns a classifier with bad samples distributed on complement of the support of the input data. But Bad GAN needs additional architectures, a generator and a density estimation model, which involves huge computation and memory consumption cost. VAT is another good semi-supervised learning algorithm, which utilizes unlabeled data to improve the invariance of the classifier with respect to perturbation of inputs. In this study, we propose a new method by combining the ideas of Bad $G A N$ and VAT. The proposed method generates bad samples of high-quality by use of the adversarial training used in VAT. We give theoretical explanations why the adversarial training is good at both generating bad samples and semi-supervised learning. An advantage of the proposed method is to achieve the competitive performances with much fewer computations. We demonstrate advantages our method by various experiments with well known benchmark image datasets. ",
+        "bbox": [
+            232,
+            281,
+            767,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            336,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has accomplished unprecedented success due to the development of deep architectures, learning techniques and hardwares (Krizhevsky et al., 2012; Ioffe & Szegedy, 2015; Szegedy et al., 2015; Hinton et al., 2012; Kingma & Ba, 2014). However, deep learning has also suffered from collecting large amount of labeled data which requires both cost and time. Thus it becomes important to develop semi-supervised methodologies that learn a classifier (or discriminator) by using small labeled data and large unlabeled data. ",
+        "bbox": [
+            173,
+            578,
+            826,
+            676
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Various semi-supervised learning methods have been proposed for deep learning. Weston et al. (2012) employs a manifold embedding technique using the pre-constructed graph of unlabeled data and Rasmus et al. (2015) uses a specially designed auto-encoder to extract essential features for classification. Variational auto encoder (Kingma & Welling, 2013) is also used in the context of semi-supervised learning by maximizing the variational lower bound of both labeled and unlabeled data (Kingma et al., 2014; Maaløe et al., 2016). ",
+        "bbox": [
+            174,
+            685,
+            826,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, semi-supervised learning based on generative adversarial networks (GAN, Goodfellow et al. (2014a)) has received much attention. For $K$ -class classification problems, Salimans et al. (2016) solves the $( K + 1 )$ -class classification problem where the additional $( K + 1 )$ th class consists of synthetic images made by a generator of the $G A N$ learned by unlabeled data. Dai et al. (2017) notices that not a good generator but a bad generator which generates synthetic images much different from observed images is crucial for the success of semi-supervised learning. Dai et al. (2017) gives theoretical justifications of using a bad generator and develops a semi-supervised learning algorithm called Bad GAN which achieves the state-of-the-art performances over multiple benchmark datasets. ",
+        "bbox": [
+            173,
+            792,
+            826,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, Bad GAN has several limitations. It needs two additional deep architectures - bad generator and pre-trained density estimation model besides the one for the classifier. Learning these multiple deep architectures requires huge computation and memory consumption. In particular, the Pixel$C N N { + + }$ (Salimans et al., 2017) is used for the pre-trained density estimation model which needs very large computational resources. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            185
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another difficulty in Bad GAN is that it requires a two-step learning procedure - the first step is to learn the $P i x e l C N N { + + }$ model and the second step is to learn the classifier and the bad generator. The optimal learning of the first step may not be optimal for the second step and hence the regularization of the both steps would need special techniques. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            258
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this study, we propose a new semi-supervised learning method which competes well with other stateof-the-art semi-supervised learning algorithms and yet needs much smaller amount of computational resources. In particular, the proposed method employs only one deep architecture and hence the corresponding learning phase is much easier and faster. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposed method is motivated by close investigation of VAT (Virtual Adversarial Training) method (Miyato et al., 2015; 2017). VAT tries to find a deep classifier which has a good prediction accuracy on training data and at the same time is less sensitive to data perturbation toward the adversarial direction. Here, the adversarial direction for a given datum is the direction to which the probabilities of each class change most. In Section 3, we prove that the perturbed data toward their adversarial directions can serve as ‘good’ bad samples. By using the adversarial directions for both measuring the invariance and generating the bad samples, the proposed method combines the advantages of Bad GAN and VAT together. Note that only a deep architecture for classification is needed to calculate the adversarial directions and thus the corresponding learning procedure is cheaper, easier and faster. We call our proposed method FAT (Fast Adversarial Training). ",
+        "bbox": [
+            173,
+            342,
+            826,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dai et al. (2017) proves that bad samples play a role to pull the decision boundary toward the low density regions of data. In Section 5, we give a theoretical explanation that VAT pushes the decision boundary away from the high density regions of data. That is, FAT accelerates the learning procedure by using both pushing and pulling operations simultaneously. In section 6, we show that $F A T$ achieves almost the state-of-the-art performances with much fewer training epochs. Especially, for the MNIST dataset, FAT achieves similar test accuracies to those of Bad GAN and VAT with 5 times and 7 times fewer training epochs, respectively. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            631
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper is organized as follows. In Section 2, we review the Bad GAN and VAT methods briefly. In Section 3, the technique to generate bad samples using the adversarial directions is described, and our proposed semi-supervised learning method is presented in Section 4. Theoretical analysis of VAT is given in Section 5. Results of various experiments are presented in Section 6 and conclusions follow in Section 7. ",
+        "bbox": [
+            174,
+            638,
+            826,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Bad GAN AND VAT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            742,
+            364,
+            760
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Bad GAN APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            776,
+            357,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Bad GAN is a method that trains a good discriminator with a bad generator. This procedure trains a generator as well as a discriminator simultaneously. Let $\\mathcal { D } _ { G } ( \\phi )$ be generated bad samples with a bad generator $p _ { G } ( \\cdot ; \\phi )$ parametrized by $\\phi$ . Here, the ‘bad generator’ is a deep architecture to generate samples different from observed data. Let $p ^ { \\mathrm { p t } } ( \\cdot )$ be a pre-trained density estimation model. For a given discriminator with a feature vector $v ( x ; \\theta )$ of a given input $x$ parameterized by $\\theta$ , Bad GAN learns the bad generator by minimizing the following: ",
+        "bbox": [
+            173,
+            804,
+            826,
+            904
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/395f99159f15a83f67e4a5575d72529cd993ea612faae593b8b73f504727fd1a.jpg",
+        "text": "$$\n\\mathbb { E } _ { x \\sim \\mathcal { D } _ { G } ( \\phi ) } \\left[ \\log p ^ { \\mathrm { p t } } ( x ) \\mathbb { I } ( p ^ { \\mathrm { p t } } ( x ) > \\tau ) \\right] + | | \\mathbb { E } _ { x \\sim \\mathcal { U } ^ { t r } } v ( x ; \\widehat { \\theta } ) - \\mathbb { E } _ { x \\sim \\mathcal { D } _ { G } ( \\phi ) } v ( x ; \\widehat { \\theta } ) | | ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            905,
+            754,
+            926
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "with respect to $\\phi$ , where $\\tau > 0$ is a tuning parameter, $\\boldsymbol { \\mathcal { U } } ^ { t r }$ is the unlabeled data, and $\\widehat { \\theta }$ is the current estimate of $\\theta$ and $\\| \\cdot \\|$ is the Euclidean norm. ",
+        "bbox": [
+            173,
+            102,
+            825,
+            136
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In turn, to train the discriminator, we consider the $K$ -class classification problem as the $( K + 1 )$ -class classification problem where the $( K + 1 )$ -th class is an artificial label of the bad samples generated by the bad generator. We estimate the parameter $\\theta$ in the discriminator by minimizing the following: ",
+        "bbox": [
+            174,
+            143,
+            826,
+            193
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e585ecfb6bb12320cf21c5b3a57a9225be34fd1fb3441fc0ba55ca2f16fe080.jpg",
+        "text": "$$\n\\begin{array} { l } { - \\mathbb { E } _ { x , y \\sim \\mathcal { L } ^ { t r } } \\left[ \\log p ( y | x , y \\leq K ; \\theta ) \\right] - \\mathbb { E } _ { x \\sim \\mathcal { U } ^ { t r } } \\left[ \\log \\left\\{ \\displaystyle \\sum _ { k = 1 } ^ { K } p ( k | x ; \\theta ) \\right\\} \\right] } \\\\ { - \\mathbb { E } _ { x \\sim \\mathcal { D } _ { G } ( \\phi ) } \\left[ \\log p ( K + 1 | x ; \\theta ) \\right] - \\mathbb { E } _ { x \\sim \\mathcal { U } ^ { t r } } \\left[ \\displaystyle \\sum _ { k = 1 } ^ { K } p ( k | x ; \\theta ) \\log p ( k | x ; \\theta ) \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            196,
+            753,
+            287
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for given $\\phi$ , where $\\mathcal { L } ^ { t r }$ is the labeled set. The second and the third terms in (1) are the cross-entropies between the unlabeled and the bad samples. The fourth term is similar the entropy of the unlabeled data which is usually helpful for semi-supervised learning (Grandvalet & Bengio, 2005). See Dai et al. (2017) for details of the objective function (1). ",
+        "bbox": [
+            173,
+            290,
+            826,
+            357
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 VAT APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            375,
+            323,
+            390
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$V A T$ is a regularization method which is inspired by the adversarial training (Goodfellow et al., 2014b). The regularization term of VAT is given as: ",
+        "bbox": [
+            173,
+            404,
+            825,
+            435
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7199df4a6e3da66374b1d33348bf16f7d305cec2eed0a7d109db87fcafd8507e.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\boldsymbol { L } ^ { \\mathrm { V A T } } ( \\boldsymbol { \\theta } ; \\widehat { \\boldsymbol { \\theta } } , \\boldsymbol { x } , \\epsilon ) } & { = } & { \\displaystyle { D _ { \\mathrm { K L } } } \\left( p ( \\cdot | \\boldsymbol { x } ; \\widehat { \\boldsymbol { \\theta } } ) | | p ( \\cdot | \\boldsymbol { x } + r _ { \\mathrm { a d v r } } ( \\boldsymbol { x } , \\epsilon ) ; \\boldsymbol { \\theta } ) \\right) } \\\\ & { = } & { \\displaystyle - \\sum _ { k = 1 } ^ { K } p ( k | \\boldsymbol { x } ; \\widehat { \\boldsymbol { \\theta } } ) \\log p ( k | \\boldsymbol { x } + r _ { \\mathrm { a d v r } } ( \\boldsymbol { x } , \\epsilon ) ; \\boldsymbol { \\theta } ) + C , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            440,
+            727,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            173,
+            517,
+            217,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6ea6a8aa0694306baf7324a71120b2c1eb722036c8f21baaba5ab559c3fd80d.jpg",
+        "text": "$$\nr _ { \\mathrm { a d v r } } ( \\boldsymbol { x } , \\epsilon ) = \\underset { r ; | \\lvert r \\rvert | \\le \\epsilon } { \\mathrm { a r g m a x } } D _ { \\mathrm { K L } } \\left( p ( \\cdot | \\boldsymbol { x } ; \\widehat { \\boldsymbol { \\theta } } ) | | p ( \\cdot | \\boldsymbol { x } + r ; \\widehat { \\boldsymbol { \\theta } } ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            526,
+            669,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\epsilon > 0$ is a tuning parameter, $\\theta$ is the parameter in the discriminator to train, $\\widehat { \\theta }$ is the current estimate of $\\theta$ and $C$ is a constant. Combining with the cross-entropy term of the labeled data, we get the final objective function of $V A T$ : ",
+        "bbox": [
+            173,
+            564,
+            825,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e8952262c7d92f319b641a2bf4dce7e19668b60ddabeab0b3caefb1671b0a20.jpg",
+        "text": "$$\n- \\mathbb { E } _ { \\boldsymbol { x } , \\boldsymbol { y } \\sim \\mathcal { L } ^ { t r } } \\left[ \\log p ( \\boldsymbol { y } | \\boldsymbol { x } ; \\boldsymbol { \\theta } ) \\right] + \\mathbb { E } _ { \\boldsymbol { x } \\sim \\mathcal { U } ^ { t r } } \\left[ \\boldsymbol { L } ^ { \\mathrm { V A T } } ( \\boldsymbol { \\theta } ; \\widehat { \\boldsymbol { \\theta } } , \\boldsymbol { x } , \\epsilon ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            618,
+            665,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 GENERATION OF BAD SAMPLES BY ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            662,
+            709,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The key role of bad samples in Bad GAN is to enforce the decision boundary to be pulled toward the low density regions of the unlabeled data. To do this, bad samples must be located at the valleys of the distribution of the unlabeled data. In this section, we propose a novel technique to generate ‘good’ bad samples by use of only a given classifier. ",
+        "bbox": [
+            173,
+            695,
+            826,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            307,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we explain why the adversarial direction is toward the decision boundary. For simplicity, we only consider the linear decision boundary. For the decision boundary made by the DNN model with ReLU activation function, see Appendix A.2. ",
+        "bbox": [
+            173,
+            808,
+            825,
+            858
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let us consider the 2-class linear logistic regression model parametrized by $\\eta = \\{ w , b \\}$ , that is, $p ( y = 1 | x ; \\eta ) = \\left( 1 + \\exp ( - b - w ^ { ' } x ) \\right) ^ { - 1 }$ . Note that the decision boundary is $\\{ x : b + w ^ { ' } x = 0 \\}$ , and for any given $x$ , the distance between $x$ and the decision boundary is $| b + w ^ { ' } x | / | | w | |$ . The key ",
+        "bbox": [
+            173,
+            866,
+            825,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5273c9df6c8b92ef502c36c1a00be0c95442c2991dc886aa558727d6656d5c25.jpg",
+        "image_caption": [
+            "Figure 1: Demonstration of how the bad samples generated by the adversarial training are distributed. We consider two cases: 3-class classification problem (Left) and 4-class classification problem (Right). True data and bad data are coloured by blue and orange, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            114,
+            647,
+            218
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "result is that moving $x$ toward the adversarial direction $r _ { \\mathrm { a d v r } } ( x , \\epsilon )$ is equivalent to moving $x$ toward the decision boundary which is stated rigorously in the following proposition. The proof is in the appendix. ",
+        "bbox": [
+            173,
+            296,
+            826,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 For a sufficiently small $\\epsilon > 0$ , we have ",
+        "bbox": [
+            173,
+            361,
+            529,
+            377
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c580ed06a641ae1e4b11a97cd0a787b16c24c478bd396523c4b6f6de00e7e62e.jpg",
+        "text": "$$\ns i g n ( w ^ { ' } x + b ) \\cdot s i g n \\left( w ^ { ' } r _ { a d \\nu r } ( x , \\epsilon ) \\right) = - 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            382,
+            642,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 implies that $| b + w ^ { ' } x | / | | w | | > | b + w ^ { ' } ( x + r ^ { \\mathrm { a d v r } } ( x , \\epsilon ) | / | | w | |$ unless $| b + w ^ { ' } x | = 0$ . Hence, we can treat $x + \\delta r _ { \\mathrm { a d v r } } ( x , \\epsilon ) / | | r ^ { \\mathrm { a d v r } } ( x , \\epsilon ) | |$ for appropriately choosing $\\delta > 0$ as a bad sample (a sample closer to the decision boundary). ",
+        "bbox": [
+            174,
+            416,
+            826,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 BAD SAMPLE GENERATION WITH GENERAL CLASSIFIER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            601,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Motivated by Proposition 1, we propose a bad sample generator as follows. Let $\\delta > 0$ be fixed and $\\widehat { \\theta }$ be the current estimate of $\\theta$ . For a given input $x$ and a classifier $p ( \\cdot | x ; \\widehat { \\theta } )$ , we calculate the adversarial direction $r _ { \\mathrm { a d v r } } ( x , \\epsilon )$ for given $\\epsilon$ by (2). Then, we consider $x _ { \\mathrm { b a d } } = x + \\delta r _ { \\mathrm { a d v r } } ( x , \\epsilon ) / \\| r _ { \\mathrm { a d v r } } ( x . \\epsilon ) \\|$ as a bad sample (a sample closer to the decision boundary). We generate bad samples for all unlabeled data. In practice, we apply the same $\\delta$ to all unlabeled data and choose $\\delta$ based on the validation data accuracy. ",
+        "bbox": [
+            173,
+            513,
+            826,
+            613
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Figure 1, we illustrate how the bad samples generated by the proposed adversarial training are distributed for multi-class problem. With a good classifier, we can clearly see that most bad samples are located well in the low density regions of the data. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It may happen that a generated bad sample is not sufficiently close to the decision boundary to be a ’good’ bad sample, in particular when $\\delta$ is too large or too small. To avoid such a situation, we exclude $x _ { \\mathrm { b a d } }$ which satisfies the following condition: ",
+        "bbox": [
+            173,
+            679,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb57dc17099205dc0b4f4601cbfcc78de50dbf47021a7ee94e6862b57d1ee515.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { k } p ( k | x _ { \\mathrm { b a d } } ; \\widehat { \\theta } ) > 1 - \\tau\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            734,
+            568,
+            760
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for a prespecified $\\tau > 0$ . In our experiments, we set the optimal $\\tau$ with validation data. ",
+        "bbox": [
+            173,
+            766,
+            741,
+            782
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 FAST ADVERSARIAL TRAINING WITH BAD SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            805,
+            635,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Once we generate bad samples by the adversarial training, $F A T$ updates $\\theta$ by minimizing the following objective function: ",
+        "bbox": [
+            174,
+            838,
+            828,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80acda50d2ca8ed125fd12bfb09969166ae678cdda5ad45e9127adf79078b16f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { - \\mathbb { E } _ { x , y \\sim \\mathcal { L } ^ { t r } } \\left[ \\log p ( y | x ; \\theta ) \\right] + \\mathbb { E } _ { x \\sim \\mathcal { U } ^ { t r } } \\left[ L ^ { \\mathrm { t r u e } } ( \\theta ; x ) \\right] + \\mathbb { E } _ { x \\sim \\mathcal { D } ^ { b a d } ( \\widehat { \\theta } , \\epsilon , \\delta ) } \\left[ L ^ { \\mathrm { f a k e } } ( \\theta , x ) \\right] } \\\\ & { + \\mathbb { E } _ { x \\sim \\mathcal { U } ^ { t r } } \\left[ L ^ { \\mathrm { V a T } } ( \\theta ; \\widehat { \\theta } , x , \\epsilon ) \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            877,
+            774,
+            930
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { D } ^ { b a d } ( \\widehat { \\theta } , \\epsilon , \\delta )$ is the set of generated bad samples with ${ \\widehat { \\theta } } , \\epsilon$ and $\\delta$ , ",
+        "bbox": [
+            174,
+            101,
+            635,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/01bfcec60ddf9c9178cb1ca26d205ec014ce2dd8583431ebfe5a21023d8ab3ba.jpg",
+        "text": "$$\n\\begin{array} { l } { { { \\cal L } ^ { \\mathrm { t r u e } } } ( \\theta ; x ) = - \\displaystyle \\sum _ { k = 1 } ^ { K } \\left[ \\displaystyle \\frac { \\exp ( g _ { k } ( x ; \\theta ) ) } { 1 + \\sum _ { k ^ { \\prime } = 1 } ^ { K } \\exp ( g _ { k ^ { \\prime } } ( x ; \\theta ) ) } \\log \\displaystyle \\frac { \\exp ( g _ { k } ( x ; \\theta ) ) } { 1 + \\sum _ { k ^ { \\prime } = 1 } ^ { K } \\exp ( g _ { k ^ { \\prime } } ( x ; \\theta ) ) } \\right] , } \\\\ { { { \\cal L } ^ { \\mathrm { f a k e } } } ( \\theta ; x ) = - \\log \\displaystyle \\frac { 1 } { 1 + \\sum _ { k = 1 } ^ { K } \\exp ( g _ { k } ( x ; \\theta ) ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            125,
+            782,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$g ( x ; \\theta ) \\in \\mathbb { R } ^ { K }$ is a pre-softmax vector of a given deep architecture and $\\lambda > 0$ . We treat $\\epsilon$ and $\\delta$ as tuning parameters to be selected based on the validation data accuracy. We minimize the objective function with one of the standard optimization algorithms such as Adam (Kingma & Ba, 2014) or RMSProp (Tieleman & Hinton, 2012). ",
+        "bbox": [
+            173,
+            213,
+            826,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The objective function (5) differs from the objective function (1) of Bad GAN in a way that the second term of (1), the cross-entropy of not being a bad sample, is deleted and the regularization term of VAT is added. We delete the second term of (1) because it can be easily shown that a perfect classifier of unlabeled data can be obtained from the minimizer of the objective function (1) without the second term under the conditions in Dai et al. (2017). The regularization term of VAT is added to improve the bad sample generator based on adversarial training. See Section 5.1 for detailed discussions. ",
+        "bbox": [
+            173,
+            286,
+            826,
+            386
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Miyato et al. (2017) proposes the fast approximation method to calculate the adversarial direction $r _ { \\mathrm { a d v r } } ( x , \\epsilon )$ by using the second-order Taylor expansion. Let us define $H ( x , { \\widehat { \\theta } } ) \\ =$ $\\nabla \\nabla D _ { \\mathrm { K L } } \\left( p ( \\cdot | x ; \\widehat { \\theta } ) | | p ( \\cdot | x + r ; \\widehat { \\theta } ) \\right) | _ { r = 0 }$ . They claim that $r _ { \\mathrm { a d v r } }$ emerges as the first dominant eigenvector $u ( x , \\widehat { \\theta } )$ of $H ( x , { \\widehat { \\theta } } )$ with magnitude $\\epsilon$ . But there always exist two dominant eigenvectors, $\\pm u ( x , \\widehat { \\theta } )$ , and the sign should be selected carefully. So, we slightly modify the approximation method of Miyato et al. (2017) by ",
+        "bbox": [
+            173,
+            393,
+            826,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a84b83dbe6579fb20f37f4d160ab1c5e4f2bb186b389afb7c27c5c457d731c53.jpg",
+        "text": "$$\nr _ { \\mathrm { a d v r } } ( \\boldsymbol { x } , \\epsilon ) = \\operatorname * { a r g m a x } _ { \\boldsymbol { r } \\in \\{ \\boldsymbol { u } ( \\boldsymbol { x } , \\widehat { \\boldsymbol { \\theta } } ) , - \\boldsymbol { u } ( \\boldsymbol { x } , \\widehat { \\boldsymbol { \\theta } } ) \\} } D _ { \\mathrm { K L } } \\left( p ( \\cdot | \\boldsymbol { x } ; \\widehat { \\boldsymbol { \\theta } } ) | | p ( \\cdot | \\boldsymbol { x } + \\boldsymbol { r } ; \\widehat { \\boldsymbol { \\theta } } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            507,
+            702,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This modification helps to improve convergence speed of the test accuracy, which will be demonstrated in the ablation experiments. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 ROLE OF VAT FOR SEMI-SUPERVISED LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            607,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate the roles of the regularization term of VAT in our method in detail. First, we verify that VAT regularization term does help to generate ’better’ bad samples with a simple experiment. Furthermore, we give a theoretical insight for the role of the regularization term of VAT in semi-supervised learning. We will show that the regularization term of VAT pushes the decision boundary from the high density regions of unlabeled data. As a result, FAT uses pushing operations by VAT term as well as pulling operations by bad samples simultaneously, which makes it possible to accelerate the training process with improved performances. ",
+        "bbox": [
+            173,
+            637,
+            826,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 IMPROVEMENT OF BAD SAMPLES WITH VAT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            772,
+            517,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For generated samples by adversarial training to be ‘good’ bad samples, the adversarial directions should be toward the decision boundary. While this always happens for the linear model by Proposition 1, adversarial directions could be opposite to the decision boundary for deep model. To avoid such undesirable cases as much as possible, it would be helpful to smoothen the classifier with a regularization term. In this section, we explain that the regularization term of VAT plays such a role. ",
+        "bbox": [
+            173,
+            801,
+            826,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The adversarial direction obtained by maximizing the KL divergence is sensitive to local fluctuations of the class probabilities which is examplified in Figure 2. The regularization term of VAT is helpful to find a right adversarial direction which is toward the decision boundary by eliminating unnecessary local fluctuations of the class probabilities. In Figure 3, we compare bad samples generated by the adversarial training with and without the regularization term of VAT for the MNIST dataset. While the bad samples generated without the regularization term of VAT are visually similar to the given input vectors, the bad samples generated with the regularization term of VAT look like mixtures of two different digits and thus serve as ‘better’ bad samples. ",
+        "bbox": [
+            174,
+            892,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc2a84b1323bfadcad3728fdd6481dc3bbfdadf75ab76068137bb03e5b8f60b7.jpg",
+        "image_caption": [
+            "Figure 2: Examples of $P ( y = 1 | x )$ of smooth (Left) and wiggle (Right) cases. We plot 3 points and their adversarial directions on each case. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            336,
+            113,
+            653,
+            218
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d07d00333c8809877229d2a92f62af0d604669ecd48bb36d5a743a2235671f26.jpg",
+        "image_caption": [
+            "Figure 3: (Upper) 10 randomly sampled original MNIST dataset. (Middle and Lower) Bad samples obtained by the classifier learned with and without the regularization term of VAT. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            275,
+            676,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            426,
+            826,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 THEORETICAL ANALYSIS OF VAT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            442,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Suppose that $\\mathcal { X }$ is partitioned by $( K + 1 )$ mutually disjoint subsets $\\mathcal { X } _ { k }$ for $k = 1 , \\ldots , K + 1$ such that $y ( x ) = k$ for all $x \\in { \\mathcal { X } } _ { k } , k \\leq K$ and $p ^ { * } ( x ) = 0$ for $x \\in \\mathcal { X } _ { K + 1 }$ , where $y ( x )$ is the ground-truth label of $x$ and $p ^ { * } ( x )$ is the true density of $x$ . For a given feature map $u : \\mathcal { X }  \\mathbb { R } ^ { m }$ and weight vectors $w _ { 1 } , \\ldots , w _ { k }$ , let $p ( y = k | x ) \\propto \\exp ( w _ { k } ^ { ' } u ( x ) )$ for $k = 1 , \\ldots , K$ and $p ( y = K + 1 | x ) \\propto 1$ . Let $\\mathcal { L } ^ { t r }$ satisfy $\\mathcal { X } _ { k } \\cap \\mathcal { L } _ { t r } \\neq \\emptyset$ for $k = 1 , . . . K$ . Suppose that (i) $\\ \\mathrm { a r g m a x } _ { h } p ( y = h | x ) = y$ for $\\boldsymbol { x } \\in \\mathcal { L } _ { t r }$ , (ii) $\\mathrm { a r g m a x } _ { h } p ( y = h | x ) \\le K$ for $x \\in \\cup _ { k = 1 } ^ { K } \\mathcal { X } _ { k }$ and (iii) argmax $\\dot { \\mathbf { \\rho } } _ { h } p ( y = h | x ) = K + 1$ for $x \\in \\mathcal { X } _ { K + 1 }$ . Under these three conditions, Dai et al. (2017) proves that $\\mathrm { a r g m a x } _ { h } p ( y = h | x ) = y ( x )$ for all $x \\in \\cup _ { k = 1 } ^ { K } \\mathcal { X } _ { k }$ . That is, generating large ‘good’ bad samples is helpful for classifying unlabeled data correctly only with a small amount of labeled data. ",
+        "bbox": [
+            173,
+            568,
+            826,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A similar result can be obtained for VAT objective function itself under mild additional conditions. For given two subsets $\\mathcal { A } _ { 1 }$ and $\\boldsymbol { A } _ { 2 }$ of $\\mathcal { X }$ , we define $\\begin{array} { r } { d ( A _ { 1 } , A _ { 2 } ) = \\operatorname* { m i n } _ { x _ { 1 } \\in A _ { 1 } , x _ { 2 } \\in A _ { 2 } } d ( x _ { 1 } , x _ { 2 } ) } \\end{array}$ for a given metric $d$ . We define a tuple $( x , x ^ { ' } )$ is $\\epsilon$ -connected if $d ( x , x ^ { ' } ) < \\epsilon$ . A finite subset $\\mathcal { A }$ of $\\mathcal { X }$ is called $\\epsilon$ -connected iff for all $x , x ^ { ' } \\in { \\mathcal { A } }$ , there exists a finite path $( x , x _ { 1 } , . . . , x _ { q } , x ^ { ' } )$ such that $x _ { j } \\in { \\mathcal { A } }$ for $j = 1 , \\dotsc , q$ an $1 ( x , x _ { 1 } ) , ( x _ { 1 } , x _ { 2 } ) , . . . , ( x _ { q - 1 } , x _ { q } ) , ( x _ { q } , x ^ { ' } )$ are all $\\epsilon$ -connected. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2 Assume that there exists $\\epsilon > 0$ such that $\\pmb { I }$ ) $\\mathcal { U } _ { k } ^ { t r } = \\mathcal { U } ^ { t r } \\cap \\mathcal { X } _ { k } , k = 1 , \\ldots , K$ are $\\epsilon$ -connected, 2) $d ( \\mathcal { X } _ { k } , \\mathcal { X } _ { k ^ { \\prime } } ) \\geq 2 \\epsilon$ for all $k \\neq k ^ { ' } \\leq K$ , and 3) for each $k \\leq K$ , there exists at least one $( x , k ) \\in \\mathcal { L } ^ { t r }$ such that $d ( \\{ x \\} , \\mathcal { U } _ { k } ^ { t r } ) < \\epsilon$ . Suppose that there exists a classifier $f : \\mathcal { X } \\to \\{ 1 , . . . , K \\}$ such that $f ( x ) = y$ for all $( x , y ) \\in \\mathcal { L } ^ { t r }$ and ",
+        "bbox": [
+            173,
+            827,
+            825,
+            893
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbea76e2c471c00e8deeff573896cd8729644c6e112dbe1ce0bf3609bbab2c08.jpg",
+        "text": "$$\nf ( x ) = f ( x ^ { ' } ) f o r a l l x ^ { ' } \\in \\mathcal { B } ( x , \\epsilon )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            905,
+            616,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for all $\\boldsymbol { x } \\in \\boldsymbol { U } ^ { t r }$ , where $\\displaystyle B ( x , \\epsilon ) = \\{ x ^ { \\prime } : d ( x , x ^ { \\prime } ) \\leq \\epsilon \\}$ . Then, the function $f$ classifies the unlabeled set perfectly, that is: ",
+        "bbox": [
+            168,
+            102,
+            825,
+            135
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a4b1b7674adecffb576a20def549322c822580cf8376dd6d1ceee792bb3a7e6.jpg",
+        "text": "$$\nf ( x ) = y ( x ) f o r a l l x \\in \\mathcal { U } ^ { t r } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            142,
+            581,
+            160
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Condition 1) and 2) mean that the unlabeled data are dense enough and the supports of each class are separated sufficiently, respectively. Condition 3) assumes that at least one labeled instance exists near the supports of each class. The main condition of Proposition 2 is (6) which essentially assumes that the classifier $f$ does not change much locally. That is, $f$ is invariant with respect to all small perturbations of an input $x$ . Note that the regularization term of $V A T$ is devised to improve the invariancy of the classifier and Proposition 2 explains why improving the invariancy is helpful for semi-supervised learning. ",
+        "bbox": [
+            173,
+            191,
+            826,
+            308
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 INTERPRETATION OF VAT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            325,
+            392,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Let $f ( x ; \\theta ) = \\mathrm { a r g m a x } _ { h } p ( y = h | x ; \\theta )$ . Proposition 2 implies that it would be good to pursue a classifier which predicts the labeled data correctly and at the same time is invariant with respect to all local perturbations on the unlabeled data. For this purpose, a plausible candidate of the objective function is ",
+        "bbox": [
+            173,
+            354,
+            826,
+            419
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d8835df86bc05d56e998910649a6c7a6fc2a6aa219ebc0cfcd5d8961452a95f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { ( { x } , { y } ) \\sim \\mathcal { L } ^ { t r } } \\left[ \\mathbb { I } ( { y } \\neq f ( { x } ; { \\theta } ) \\right] + \\mathbb { E } _ { { x } \\sim \\mathcal { U } ^ { t r } } \\left[ \\mathbb { I } \\left( f ( { x } ; { \\theta } ) \\neq f ( { x } ^ { ' } ; { \\theta } ) \\mathrm { ~ f o r ~ } { \\forall x } ^ { ' } \\in \\mathcal { B } ( { x } , { \\epsilon } ) \\right) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            422,
+            753,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Note that a classifier $f$ which achieves 0 value of the objective function (7) satisfies the conditions of Proposition 2 and thus classifies all unlabeled data correctly. ",
+        "bbox": [
+            174,
+            455,
+            823,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The objective function (7) is not practically usable since neither optimizing the indicator function nor checking $f ( x ; \\theta ) \\neq f ( x ^ { ' } ; \\theta )$ for all $x ^ { ' }$ in $B ( x , \\epsilon )$ is possible. To resolve these problems, we replace the indicator functions in (7) with the cross-entropies, and the neighborhood $B ( x , \\epsilon )$ in the second term with the adversarial direction. By doing so, we have the following alternative objective function: ",
+        "bbox": [
+            174,
+            494,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14df001398688268e866fa469ec37aa4d62117c3dd5cbf53251d6598c6cddb01.jpg",
+        "text": "$$\n- \\mathbb { E } _ { x , y \\sim \\mathcal { L } ^ { t r } } \\left[ \\log p ( y | x ; \\theta ) \\right] - \\mathbb { E } _ { x \\sim \\mathcal { U } ^ { t r } } \\left[ \\sum _ { k = 1 } ^ { K } p ( k | x ; \\theta ) \\log p ( k | x + r _ { \\mathrm { a d v r } } ( x , \\epsilon ) ; \\theta ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            565,
+            764,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we replace $p ( \\cdot | x ; \\theta )$ in the second term of (8) by $p ( \\cdot | x ; \\widehat { \\theta } )$ to have the objective function of VAT (3). ",
+        "bbox": [
+            176,
+            616,
+            825,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The condition (6) in Proposition 2 means that the decision boundary is not located inside the support $\\mathcal { X } _ { k }$ of each class. That is, the regularization term of VAT prevents the decision boundary from being located at the high density regions of data or equivalently pushes the decision boundary from the high density regions of data. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            326,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 PREDICTION PERFORMANCES IN SEMI-SUPERVISED LEARNING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            647,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare prediction performances of $F A T$ over the benchmark datasets with other semi-supervised learning algorithms. We consider the most widely used datasets: MNIST (LeCun et al., 1998), SVHN (Marlin et al., 2010) and CIFAR10 (Krizhevsky & Hinton, 2009). As in done by other works, we randomly sample 100, 1000 and 4000 labeled data from the MNIST, SVHN and CIFAR10 datasets, respectively and use them as the labeled data and the rest as the unlabeled data. For fair comparison, we use the same architectures as those used in Miyato et al. (2017) for MNIST, SVHN and CIFAR10. The optimal tuning parameters $( \\epsilon , \\tau , \\delta )$ in $F A T$ are chosen based on the validation data accuracy. ",
+        "bbox": [
+            173,
+            808,
+            826,
+            925
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e3cb85558c7e297e29c058ef0e97b20035195d64432d69a8654fb10da9cddf5.jpg",
+        "table_caption": [
+            "Table 1: Comparison of prediction accuracies of various semi-supervised learning algorithms for the three benchmark datasets. mod. VAT is the modified version of VAT stated in Section 4. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td colspan=\"3\">Test acc.(%)</td></tr><tr><td></td><td>MNIST(100)</td><td>SVHN(1000)</td><td>CIFAR10(4000)</td></tr><tr><td>DGN (Kingma et al., 2014)</td><td>96.67</td><td>63.98</td><td>-</td></tr><tr><td>Ladder (Rasmus et al., 2015)</td><td>98.94</td><td>1</td><td>79.6</td></tr><tr><td>ALI (Donahue et al., 2016)</td><td>1</td><td>92.58</td><td>82.01</td></tr><tr><td>FM-GAN (Salimans et al.,2016)</td><td>99.07</td><td>91.89</td><td>81.37</td></tr><tr><td>FM-GAN-Tan (Kumar et al., 2017)</td><td>1</td><td>95.61</td><td>83.80</td></tr><tr><td>Bad GAN (Dai et al., 2017)</td><td>99.20</td><td>95.75</td><td>85.59</td></tr><tr><td>VAT (Miyato et al., 2017)</td><td>98.64</td><td>93.17</td><td>85.13</td></tr><tr><td>CrossEnt (use all data)</td><td>98.82</td><td>96.74</td><td>90.31</td></tr><tr><td>CrossEnt (use lab. data only)</td><td>79.16</td><td>88.91</td><td>67.45</td></tr><tr><td>mod. VAT</td><td>98.70</td><td>94.69</td><td>85.18</td></tr><tr><td>FAT</td><td>98.89</td><td>95.94</td><td>85.31</td></tr></table>",
+        "bbox": [
+            200,
+            136,
+            792,
+            356
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5f90a3dc983d47a61cf7b46088d28955953ca1129b27f30de804d8b76039b607.jpg",
+        "table_caption": [
+            "Table 2: Comparison of prediction accuracies with small labeled data and more complex dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"4\">Test acc.(%)</td></tr><tr><td>MNIST(20)</td><td>SVHN(500)</td><td>CIFAR10(1000)</td><td>CIFAR100(8000)</td></tr><tr><td>FM-GAN (Salimans et al., 2016)</td><td>83.23</td><td>81.56</td><td>78.13</td><td>-</td></tr><tr><td>FM-GAN-Tan (Salimans et al., 2016)</td><td>-</td><td>95.13</td><td>80.48</td><td>1</td></tr><tr><td>CrossEnt(use all data)</td><td>98.82</td><td>96.74</td><td>90.31</td><td>46.72</td></tr><tr><td>CrossEnt(use lab.data only)</td><td>54.92</td><td>85.82</td><td>50.30</td><td>18.35</td></tr><tr><td>mod. VAT</td><td>89.92</td><td>92.59</td><td>75.43</td><td>34.76</td></tr><tr><td>FAT</td><td>96.32</td><td>95.21</td><td>75.96</td><td>35.52</td></tr></table>",
+        "bbox": [
+            173,
+            415,
+            833,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use Adam algorithm (Kingma & Ba, 2014) to update the parameters and do not use any data augmentation techniques. The results are summarized in Table 1, which shows that $F A T$ achieves the state-of-the-art accuracy for SVHN dataset and competitive accuracies with the state-of-the-art method (i.e. Bad GAN) for MNIST and CIFAR10. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We conduct another experiments where the numbers of labeled data are much smaller and consider a more complex dataset CIFAR100 (Krizhevsky & Hinton, 2009), whose results are summarized in Table 2. Note that FAT still dominates mod. VAT for the all datasets and the margins become larger. While $F A T$ achieves the state-of-the-art performances for MNIST and SVHN, its performance degrades much for CIFAR10 compared to the accuracy for the case of 4000 labeled data. Note that the quality of bad samples depends on the quality of the estimated classifier. For CIFAR10 which is relatively more complex than MNIST and SVHN, the quality of the estimated classifier is influenced much to the amount of labeled data and thus the accuracy of $F A T$ is more sensitive to the amount of labeled data. However, it is interesting to see that $F A T$ is superior to mod. VAT for CIFAR10 and CIFAR100, which suggests that bad samples are helpful for complex problems where the quality of bad samples might not be sufficiently good. ",
+        "bbox": [
+            173,
+            669,
+            826,
+            851
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The other advantage of $F A T$ is its stability with respect to learning phase. With small labeled data, the test accuracies of each epoch tends to fluctuate much for VAT and mod VAT, while $F A T$ provides much more stable results. See Figure 7 in Appendix. This may be partly because ’good’ bad samples keep the classifier from fluctuation. ",
+        "bbox": [
+            174,
+            859,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4fd3fd7b471ec3e04986dccc3908deee8bba72d6cf1be341ad9431d34bd21188.jpg",
+        "table_caption": [
+            "Table 3: Test accuracies of MNIST for various values of $\\tau$ and $\\delta$ . The other two parameters on each case are fixed to the optimal values. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>T</td><td>0.001</td><td>0.01</td><td>0.1</td><td>0.2</td></tr><tr><td>Test acc.</td><td>98.65</td><td>98.89</td><td>98.77</td><td>98.71</td></tr></table>",
+        "bbox": [
+            184,
+            135,
+            488,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/67d00f74fdb29b8c0083063fcc0765204cd9156f7f9296a5e7266b606a6ec020.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>8</td><td>1</td><td>2.</td><td>4.</td><td>6.</td></tr><tr><td>Test acc.</td><td>89.54</td><td>98.89</td><td>98.79</td><td>98.55</td></tr></table>",
+        "bbox": [
+            504,
+            136,
+            808,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6cd8e5ef5f318d10810cdc2f6413c1841437c10b899076c52bb695d64fcdb453.jpg",
+        "table_caption": [
+            "Table 4: Test accuracies for diverse objective loss functions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data Setting</td><td>MNIST</td><td>SVHN</td><td>CIFAR10</td></tr><tr><td>Ltrue +Lfake +LVAT</td><td>98.89</td><td>Test acc.(%) 95.94</td><td>85.15</td></tr><tr><td>Ltrue +Lfake</td><td>83.6</td><td>90.21</td><td>68.32</td></tr><tr><td>Lfake+ LVAT</td><td>98.77</td><td>95.71</td><td>85.31</td></tr></table>",
+        "bbox": [
+            308,
+            215,
+            683,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 EFFECTS OF TUNING PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            454,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "$F A T$ introduces two additional tuning parameters $\\tau$ and $\\delta$ compared to VAT, where $\\tau$ is used to determine whether a bad sample is ’good’ and $\\delta$ is the radius to generate bad samples. We investigate the sensitivities of prediction performances with respect to the changes of the values of $\\tau$ and $\\delta$ with $\\epsilon$ being fixed at 1.5 that is the optimal value. The results are reported in Table 3. Unless $\\tau$ is too small or too large, the prediction performances are not changed much. For $\\delta$ , care should be done. Too small $\\delta$ , smaller than \u000f, hampers the prediction performance much. Apparently, a similar value of $\\delta$ to that of $\\epsilon$ (i.e. $\\delta = 2$ ) gives the best result. ",
+        "bbox": [
+            173,
+            372,
+            826,
+            487
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.3 OBJECTIVE FUNCTION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            442,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we analyze the effects of $L ^ { \\mathrm { t r u e } }$ and $L ^ { \\mathrm { V A T } }$ in this section. We do not consider the cross-entropy of the labeled data and $L ^ { \\mathrm { f a k e } }$ since they are necessary to reflect the idea utilizing bad data. Table 4 compares the performances without one or both of these terms. Note that $L ^ { \\mathrm { V A T } }$ is necessary for superior performances, which is because $L ^ { \\mathrm { V A T } }$ is indispensable to generate ‘good’ bad samples as explained in Section 5.1. On the other hand, the term $L ^ { \\mathrm { t r u e } }$ , which is devised to separate unlabeled data from bad samples, is not always helpful. A possible explanation is that sometimes the term $L ^ { \\mathrm { t r u e } }$ would give an undesirable effect on the misclassified data. ",
+        "bbox": [
+            173,
+            544,
+            826,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.4 COMPUTATIONAL EFFICIENCY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            688,
+            421,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We investigate the computational efficiency of our method in view of learning speed and computation time per training epoch. For Bad GAN, we did not use $P i x e l C N N { + + }$ on SVHN and CIFAR10 datasets since the pre-trained $P i x e l C N N { + + }$ models are not publicly available. Figure 4 draws the bar plots about the numbers of epochs needed to achieve the prespecified test accuracies. We can clearly see that $F A T$ requires much less epochs ",
+        "bbox": [
+            173,
+            718,
+            825,
+            800
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also calculate the ratios of the computing time of each semi-supervised learning algorithm over the computing time of the corresponding supervised learning algorithm for CIFAR10 dataset, whose results are summarized in Table 5. These ratios are almost same for different datasets. The computation time of $F A T$ is competitive to VAT and mod. VAT, and hence we can conclude that $F A T$ arrives at the prespecified performances much efficiently. Note that $P i x e l C N N { + + }$ is not used for this experiment, and so comparison of computing time of $F A T$ and Bad GAN with $P i x e l C N N + +$ is meaningless ",
+        "bbox": [
+            173,
+            809,
+            826,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a65d8b5b70ee0c028d73f8d35c14f7ed23be19f1820366a082249f31828e737.jpg",
+        "image_caption": [
+            "Figure 4: The number of epochs to achieve the prespecified test accuracies $9 8 \\%$ , $90 \\%$ and $80 \\%$ ) with the four methods for (Left) MNIST, (Middle) SVHN and (Right) CIFAR10 datasets. Bad $G A N$ is operated without $P i x e l C N N + +$ for SVHN and CIFAR10 datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            109,
+            686,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/246f5fd6a48311e754d0363bb771d0237defb225fc378aa8cf25dabd3ba44b6f.jpg",
+        "table_caption": [
+            "Table 5: Learning time per training epoch ratios compared to supervised learning with cross-entropy for CIFAR10. Bad GAN is operated without $P i x e l C N N + +$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>VAT</td><td>mod. VAT</td><td>FAT</td><td>Bad GAN</td></tr><tr><td>Time ratio</td><td>1.37</td><td>1.62</td><td>2.09</td><td>3.20</td></tr></table>",
+        "bbox": [
+            318,
+            306,
+            676,
+            342
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6.5 QUALITY OF BAD SAMPLES GENERATED BY ADVERSARIAL TRAINING",
+        "text_level": 1,
+        "bbox": [
+            173,
+            386,
+            694,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We investigate how ‘good’ bad samples generated by the adversarial training are. The upper panel of Figure 5 shows the scatter plot of the synthetic data and the trace plot of prediction accuracies of $F A T$ and VAT. And the lower panel of Figure 5 draws the scatter plots with generated bad samples at various epochs. We can clearly see that bad samples move to lower density regions as the epoch increases, which amply demonstrates that the adversarial training is good at generating bad samples. We also compare bad images of the MNIST data generated by $F A T$ and Bad GAN in Figure 6. The bad images by $F A T$ do not look like real images and do not seem to be collapsed, which indicates that $F A T$ consistently generates diverse and good bad samples. Bad GAN also generates diverse bad samples but some ‘realistic’ images can be found. ",
+        "bbox": [
+            173,
+            417,
+            826,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            601,
+            318,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new method called FAT for semi-supervised learning which generates bad samples only with a given classifier. The objective function of $F A T$ is devised to compromise the advantages of Bad GAN and VAT together, which makes $F A T$ be faster and more accurate. In numerical experiments, we show that $F A T$ achieves almost the state-of-the-art performances with much fewer epochs. Unlike Bad GAN , $F A T$ only needs to learn a discriminator. Hence, it could be extended without much effort to other learning problems. For example, $F A T$ can be modified easily for recurrent neural networks and hence can be applied to sequential data. We will leave this extension as a future work. ",
+        "bbox": [
+            173,
+            642,
+            826,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "It would be useful to combine $F A T$ with a generative approach such as Bad GAN, in particular when the initial classifier is bad. Since FAT uses only a classifier to generate bad samples, the initial estimate of the classifier would be important. Using the generator model learned by large unlabeled data would be helpful to find a good initial estimate of the classifier. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            878,
+            326,
+            891
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work is supported by Samsung Electronics Co., Ltd. ",
+        "bbox": [
+            174,
+            909,
+            549,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/911fdbc2dd3e183753ca3d8c54938f735c0cd0ea5edd11ed47ada3b801239e24.jpg",
+        "image_caption": [
+            "Figure 5: (Upper Left) The scatter plot of synthetic data which consist of 1000 unlabeled data (gray) and 4 labeled data for each class (red and blue with black edge). (Upper Right) Accuracies of unlabeled data for each epochs for VAT and FAT. We use 2-layered NN with 100 hidden units each. (Lower) Bad samples and classified unlabeled data by colors at the different training epochs of FAT "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            263,
+            111,
+            730,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/518422245968365df9605efa288ca84be63a6bea1214a3f5fc3d22a49c2d6611.jpg",
+        "image_caption": [
+            "Figure 6: 100 randomly sampled bad images using (Left) FAT and (Right) Bad GAN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            320,
+            362,
+            673,
+            489
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            535,
+            287,
+            550
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zihang Dai, Zhilin Yang, Fan Yang, William W Cohen, and Ruslan R Salakhutdinov. Good semisupervised learning that requires a bad gan. In Advances in Neural Information Processing Systems, pp. 6513–6523, 2017. ",
+        "bbox": [
+            174,
+            561,
+            826,
+            609
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016. ",
+        "bbox": [
+            171,
+            625,
+            825,
+            656
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014a. ",
+        "bbox": [
+            173,
+            671,
+            826,
+            720
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014b. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            767
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In Advances in neural information processing systems, pp. 529–536, 2005. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            814
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012. ",
+        "bbox": [
+            173,
+            828,
+            826,
+            877
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            176,
+            892,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            136
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik $\\mathrm { \\bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            171,
+            148,
+            823,
+            181
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma, Shakir Mohamed, Danilo Jimenez Rezende, and Max Welling. Semi-supervised learning with deep generative models. In Advances in Neural Information Processing Systems, pp. 3581–3589, 2014. ",
+        "bbox": [
+            173,
+            194,
+            826,
+            243
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            174,
+            256,
+            823,
+            290
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            173,
+            301,
+            828,
+            351
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Kumar, Prasanna Sattigeri, and Tom Fletcher. Semi-supervised learning with gans: manifold invariance with improved inference. In Advances in Neural Information Processing Systems, pp. 5534–5544, 2017. ",
+        "bbox": [
+            174,
+            364,
+            826,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            169,
+            426,
+            825,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lars Maaløe, Casper Kaae Sønderby, Søren Kaae Sønderby, and Ole Winther. Auxiliary deep generative models. arXiv preprint arXiv:1602.05473, 2016. ",
+        "bbox": [
+            173,
+            472,
+            823,
+            506
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Marlin, Kevin Swersky, Bo Chen, and Nando Freitas. Inductive principles for restricted boltzmann machine learning. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pp. 509–516, 2010. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional smoothing with virtual adversarial training. arXiv preprint arXiv:1507.00677, 2015. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            613
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. arXiv preprint arXiv:1704.03976, 2017. ",
+        "bbox": [
+            173,
+            626,
+            828,
+            675
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semi-supervised learning with ladder networks. In Advances in Neural Information Processing Systems, pp. 3546– 3554, 2015. ",
+        "bbox": [
+            173,
+            688,
+            826,
+            737
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016. ",
+        "bbox": [
+            173,
+            750,
+            828,
+            800
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Andrej Karpathy, Xi Chen, and Diederik P Kingma. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. arXiv preprint arXiv:1701.05517, 2017. ",
+        "bbox": [
+            173,
+            813,
+            825,
+            862
+        ],
+        "page_idx": 11
+    },
+    {
+        "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": [
+            173,
+            875,
+            826,
+            925
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26–31, 2012. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            151
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Frédéric Ratle, Hossein Mobahi, and Ronan Collobert. Deep learning via semisupervised embedding. In Neural Networks: Tricks of the Trade, pp. 639–655. Springer, 2012. ",
+        "bbox": [
+            173,
+            162,
+            826,
+            195
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 PROOF OF PROPOSITION 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            400,
+            151
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Without loss of generality, we assume that $w ^ { ' } x + b > 0$ , that is, $p ( y = 1 | x ; \\eta ) > p ( y = 0 | x ; \\eta )$ . We will show that there exists $\\epsilon > 0$ such that $w ^ { ' } r ^ { * } ( x , \\epsilon ) < 0$ . Note that ",
+        "bbox": [
+            173,
+            162,
+            825,
+            196
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f05e98022100f44cc30539ba0eb3a98feac8311fc2c519e9aa35bd3c8b3013d.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\operatorname * { a r g m a x } _ { \\begin{array} { l } { r , | | x | | \\leq \\epsilon , w ^ { \\prime } r > 0 } \\\\ { \\operatorname * { a r g m a x } _ { \\begin{array} { l } { K L ( x , r ; \\eta ) = - \\epsilon } \\\\ { r , | | w | | \\leq \\epsilon , w ^ { \\prime } r < 0 } \\end{array} } } \\textstyle K L ( x , r ; \\eta ) = \\epsilon \\frac { w } { | | w | | } ( = : r _ { 1 } ^ { * } ) \\quad \\mathrm { a n d } } } \\end{array} }  \\\\ & { } &  \\operatorname * { a r g m a x } _ { \\begin{array} { l } { K L ( x , r ; \\eta ) = - \\epsilon \\frac { w } { | | w | | } ( = : r _ { 2 } ^ { * } ) . } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            203,
+            678,
+            273
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "So all we have to do is to show ",
+        "bbox": [
+            173,
+            280,
+            379,
+            294
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3eebb2576ac6206282cb1146e8cc03f05ee2c3293a0316544f5aa3e6927116d8.jpg",
+        "text": "$$\nK L ( x , r _ { 2 } ^ { * } ; \\eta ) > K L ( x , r _ { 1 } ^ { * } ; \\eta ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            304,
+            599,
+            321
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "By simple calculation we can get the following: ",
+        "bbox": [
+            173,
+            330,
+            488,
+            347
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f6fed3b8017eef33c4bd8218d302b752642e23952c6faa9a54762bbefb94588.jpg",
+        "text": "$$\n\\small \\begin{array} { r } { \\nabla L ( x , r _ { 2 } ^ { * } ; \\eta ) - K L ( x , r _ { 1 } ^ { * } ; \\eta ) = - \\left[ p ( y = 1 | x ; \\theta ) w ^ { ' } ( r _ { 2 } ^ { * } - r _ { 1 } ^ { * } ) - \\log \\frac { \\exp \\big ( w ^ { ' } ( x + r _ { 2 } ^ { * } ) + b \\big ) + 1 } { \\exp ( w ^ { ' } ( x + r _ { 1 } ^ { * } ) + b ) + 1 } \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            352,
+            826,
+            404
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Using the Taylor’s expansion up to the third-order, we obtain the following: ",
+        "bbox": [
+            173,
+            409,
+            669,
+            425
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4892bbf8d7badf9d5ae4af166ca02eb7a06d688c8306caa4916533becdaea177.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\log \\Big [ \\exp \\Big ( w ^ { ' } ( x + r ) + b \\Big ) + 1 \\Big ] } & { = } & { \\log \\Big [ \\exp \\Big ( w ^ { ' } x + b \\Big ) + 1 \\Big ] + p ( y = 1 | x ; \\eta ) w ^ { ' } r } \\\\ & & { } & { + \\displaystyle \\frac { 1 } { 2 } p ( y = 1 | x ; \\eta ) p ( y = 0 | x ; \\eta ) r ^ { ' } w w ^ { ' } r } \\\\ & & { } & { - \\displaystyle \\frac { 1 } { 6 } p ( y = 1 | x ; \\eta ) p ( y = 0 | x ; \\eta ) \\left\\{ p ( y = 1 | x ; \\eta ) - p ( y = 0 | x ; \\eta ) \\right. } \\\\ & & { } & { \\left. + o ( | | r | | ^ { 3 } ) . \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            429,
+            839,
+            555
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "So, ",
+        "bbox": [
+            173,
+            563,
+            199,
+            575
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aaea2bfd3be8d32bf0c87416dde9c038e4b17ac76ab01c7f581bcf3e28faa439.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\frac { \\ d s ^ { \\prime } ( x + r _ { 2 } ^ { \\ast } ) + \\ d b \\Big ) + 1 } { \\ d y ^ { \\prime } ( x + r _ { 1 } ^ { \\ast } ) + \\ d b ) + 1 } } & { = } & { p ( y = 1 | x ; \\eta ) w ^ { ' } ( r _ { 2 } ^ { \\ast } - r _ { 1 } ^ { \\ast } ) } \\\\ & & { + \\frac { 1 } { 3 } p ( y = 1 | x ; \\eta ) p ( y = 0 | x ; \\eta ) \\left\\{ p ( y = 1 | x ; \\eta ) - p ( y = 0 | x ; \\eta ) \\right\\} \\epsilon ^ { 3 } | | w | | ^ { 3 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            583,
+            905,
+            659
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Thus, we have the following equations: ",
+        "bbox": [
+            173,
+            662,
+            431,
+            678
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1812823b8e9f2e69509e9490d5b8449ce8b6955f353d2803a7e59aac2b0b5122.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\check { \\operatorname { \\tiny { C } } } L ( x , r _ { 2 } ^ { * } ; \\eta ) - K L ( x , r _ { 1 } ^ { * } ; \\eta ) } & { = } & { \\frac { 1 } { 3 } p ( y = 1 | x ; \\eta ) p ( y = 0 | x ; \\eta ) \\left\\{ p ( y = 1 | x ; \\eta ) - p ( y = 0 | x ; \\eta ) \\right\\} \\epsilon ^ { 3 } } \\\\ & & { = } & { C \\cdot \\epsilon ^ { 3 } + o ( \\epsilon ^ { 3 } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            683,
+            839,
+            734
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Therefore, there exists $\\epsilon ^ { * } > 0$ such that $K L ( x , r _ { 2 } ^ { * } ; \\eta ) > K L ( x , r _ { 1 } ^ { * } ; \\eta )$ for $\\forall 0 < \\epsilon < \\epsilon ^ { * }$ . \u0003 ",
+        "bbox": [
+            169,
+            741,
+            769,
+            758
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 EXTENSION OF PROPOSITION 1 FOR THE DNN CLASSIFIER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            789,
+            625,
+            806
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Consider a binary classification DNN model with ReLU activation function $p ( y = 1 | x ; \\theta ) ~ =$ $( 1 + \\exp ( - g ( x ; \\theta ) ) ) ^ { - 1 }$ parameterized by $\\theta$ . Since $g ( x ; \\theta )$ is piecewise linear, we can write $g ( \\cdot ; \\theta )$ as ",
+        "bbox": [
+            173,
+            818,
+            826,
+            852
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c16b2a23606e087a451081e9b3b02543f18ace44450042d8e1e56c6c8495869.jpg",
+        "text": "$$\ng ( \\cdot ; \\theta ) = \\sum _ { j = 1 } ^ { N } \\mathbb { I } ( \\cdot \\in \\mathcal { A } _ { j } ) \\cdot ( w _ { j } x + b _ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            858,
+            604,
+            902
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $A _ { j }$ is a linear region and $N$ is the number of linear regions. ",
+        "bbox": [
+            171,
+            909,
+            606,
+            925
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For given $x$ , suppose $g ( x ; \\theta ) > 0$ . If $g ( x : \\theta )$ is estimated reasonably, we expect that $g ( x ; \\theta )$ is decreasing if $x$ moves toward the decision boundary. A formal statement of this expectation would be that $x - r \\nabla _ { x } g ( x ; \\theta )$ can arrive at the decision boundary for a finite value of $r > 0$ , where $\\nabla _ { x }$ is the gradient with respect to $x$ . Of course, for $x$ with $g ( x ; \\theta ) < 0$ , we expect that $x + r \\nabla _ { x } g ( x ; \\theta )$ can arrive at the decision boundary for a finite value of $r > 0$ . We say that $x$ is normal if there is $r > 0$ such that $x - r \\nabla _ { x } g ( x : \\theta ) \\mathrm { s i g n } \\{ g ( x : \\theta ) \\}$ locates at the decision boundary. We say that a linear region $A _ { j }$ is normal if all $x$ in $A _ { j }$ are normal. We expect that most of $A _ { j }$ are normal if $g ( x ; \\theta )$ is reasonably estimated so that the probability decreases or increases depending on $\\operatorname { s i g n } \\{ g ( x : \\theta ) \\}$ if $x$ is getting closer to the decision boundary. ",
+        "bbox": [
+            173,
+            102,
+            826,
+            252
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The following proposition proves that the adversarial direction is toward the decision boundary for all xs in normal linear regions. ",
+        "bbox": [
+            173,
+            260,
+            823,
+            292
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3 If a linear region $A _ { j }$ is normal. Then for any $x \\in i n t ( \\mathcal { A } _ { j } )$ , there exists $\\epsilon > 0$ and $\\delta > 0$ such that $x _ { b a d } = x + \\delta r _ { a d \\nu r } ( x , \\epsilon ) / | | r _ { a d \\nu r } ( x , \\epsilon ) | |$ is on the decision boundary. ",
+        "bbox": [
+            171,
+            306,
+            823,
+            340
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Proof. Take $\\tilde { \\epsilon } > 0$ such that $\\boldsymbol { x } + \\boldsymbol { r } \\in \\mathcal { A } _ { \\tilde { \\boldsymbol { j } } }$ for $\\forall r \\in B ( x , \\tilde { \\epsilon } )$ . Then by Proposition 1, there exists $0 < \\epsilon ^ { * } < \\tilde { \\epsilon }$ such that for $\\forall 0 < \\epsilon < \\epsilon ^ { * }$ , ",
+        "bbox": [
+            173,
+            347,
+            821,
+            380
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f341ce4cdce3b4970402ec976dcd9b809385e60556d9c4b00fb4a4e61aaa497c.jpg",
+        "text": "$$\n\\begin{array} { r c l } { r _ { \\mathrm { a d v r } } ( \\boldsymbol { x } , \\epsilon ) } & { = } & { \\epsilon \\cdot \\mathrm { s i g n } ( - b _ { \\tilde { j } } - w _ { \\tilde { j } } ^ { ' } x ) ) \\cdot \\frac { w _ { \\tilde { j } } } { | | w _ { \\tilde { j } } | | } } \\\\ & { \\propto } & { - \\nabla _ { x } g ( x ; \\theta ) \\mathrm { s i g n } \\{ g ( x : \\theta ) \\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            385,
+            651,
+            439
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$x$ is normal, thus there exists $\\delta > 0$ such that $x _ { \\mathrm { b a d } } = x + \\delta r _ { \\mathrm { a d v r } } ( x , \\epsilon ) / | | r _ { \\mathrm { a d v r } } ( x , \\epsilon ) | |$ belongs to the decision boundary. \u0003 ",
+        "bbox": [
+            173,
+            445,
+            825,
+            478
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3 PROOF OF PROPOSITION 2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            401,
+            525
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "It suffices to show that $\\forall x , x ^ { ' } \\in \\mathcal { U } _ { k } ^ { t r } , f ( x ) = f ( x ^ { ' } )$ for all $k = 1 , . . . , K$ . For given $\\mathcal { U } _ { k } ^ { t r }$ , there exists $( \\tilde { x } , \\tilde { y } ) \\in \\mathcal { L } ^ { t r }$ such that $d ( \\{ \\tilde { x } \\} , \\mathcal { U } _ { k } ^ { t r } ) < \\epsilon$ . So ${ \\mathcal { U } } _ { k } ^ { t r } \\cup \\{ { \\tilde { x } } \\}$ is $\\epsilon$ -connected. That is, for any $x \\in \\mathcal { U } _ { k } ^ { t r }$ , there exists a path $( \\tilde { x } , x _ { 1 } , . . . , x _ { q } , x )$ such that $( \\tilde { x } , x _ { 1 } ) , . . . , ( x _ { q } , x )$ are all $\\epsilon$ -connected. Therefore $y ( x ) = y ( \\tilde { x } ) = \\tilde { y }$ for $\\forall x \\in \\mathcal { U } _ { k } ^ { t r }$ , and the proof is done. \u0003 ",
+        "bbox": [
+            173,
+            536,
+            826,
+            606
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 FIGURE ",
+        "bbox": [
+            174,
+            103,
+            272,
+            117
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ce452a1c9709c09910e96f7d3597906a34147eb69b85bfd3aa25020a9ebafd2.jpg",
+        "image_caption": [
+            "Figure 7: Trace plot of the test accuracies with the four methods for MNIST dataset. 20 randomly sampled data are used as the labeled data and the rest are used as the unlabeled data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            159,
+            632,
+            376
+        ],
+        "page_idx": 15
+    }
+]

parse/train/HyxCxhRcY7/HyxCxhRcY7.md

@@ -0,0 +1,396 @@
+# DEEP ANOMALY DETECTION WITH OUTLIER EXPOSURE
+
+Dan Hendrycks University of California, Berkeley hendrycks@berkeley.edu
+
+Mantas Mazeika University of Chicago mantas@ttic.edu
+
+Thomas Dietterich Oregon State University tgd@oregonstate.edu
+
+# ABSTRACT
+
+It is important to detect anomalous inputs when deploying machine learning systems. The use of larger and more complex inputs in deep learning magnifies the difficulty of distinguishing between anomalous and in-distribution examples. At the same time, diverse image and text data are available in enormous quantities. We propose leveraging these data to improve deep anomaly detection by training anomaly detectors against an auxiliary dataset of outliers, an approach we call Outlier Exposure (OE). This enables anomaly detectors to generalize and detect unseen anomalies. In extensive experiments on natural language processing and small- and large-scale vision tasks, we find that Outlier Exposure significantly improves detection performance. We also observe that cutting-edge generative models trained on CIFAR-10 may assign higher likelihoods to SVHN images than to CIFAR-10 images; we use OE to mitigate this issue. We also analyze the flexibility and robustness of Outlier Exposure, and identify characteristics of the auxiliary dataset that improve performance.
+
+# 1 INTRODUCTION
+
+Machine Learning systems in deployment often encounter data that is unlike the model’s training data. This can occur in discovering novel astronomical phenomena, finding unknown diseases, or detecting sensor failure. In these situations, models that can detect anomalies (Liu et al., 2018; Emmott et al., 2013) are capable of correctly flagging unusual examples for human intervention, or carefully proceeding with a more conservative fallback policy.
+
+Behind many machine learning systems are deep learning models (Krizhevsky et al., 2012) which can provide high performance in a variety of applications, so long as the data seen at test time is similar to the training data. However, when there is a distribution mismatch, deep neural network classifiers tend to give high confidence predictions on anomalous test examples (Nguyen et al., 2015). This can invalidate the use of prediction probabilities as calibrated confidence estimates (Guo et al., 2017), and makes detecting anomalous examples doubly important.
+
+Several previous works seek to address these problems by giving deep neural network classifiers a means of assigning anomaly scores to inputs. These scores can then be used for detecting outof-distribution (OOD) examples (Hendrycks & Gimpel, 2017; Lee et al., 2018; Liu et al., 2018). These approaches have been demonstrated to work surprisingly well for complex input spaces, such as images, text, and speech. Moreover, they do not require modeling the full data distribution, but instead can use heuristics for detecting unmodeled phenomena. Several of these methods detect unmodeled phenomena by using representations from only in-distribution data.
+
+In this paper, we investigate a complementary method where we train models to detect unmodeled data by learning cues for whether an input is unmodeled. While it is difficult to model the full data distribution, we can learn effective heuristics for detecting out-of-distribution inputs by exposing the model to OOD examples, thus learning a more conservative concept of the inliers and enabling the detection of novel forms of anomalies. We propose leveraging diverse, realistic datasets for this purpose, with a method we call Outlier Exposure (OE). OE provides a simple and effective way to consistently improve existing methods for OOD detection.
+
+Through numerous experiments, we extensively evaluate the broad applicability of Outlier Exposure. For multiclass neural networks, we provide thorough results on Computer Vision and Natural
+
+Language Processing tasks which show that Outlier Exposure can help anomaly detectors generalize to and perform well on unseen distributions of outliers, even on large-scale images. We also demonstrate that Outlier Exposure provides gains over several existing approaches to out-of-distribution detection. Our results also show the flexibility of Outlier Exposure, as we can train various models with different sources of outlier distributions. Additionally, we establish that Outlier Exposure can make density estimates of OOD samples significantly more useful for OOD detection. Finally, we demonstrate that Outlier Exposure improves the calibration of neural network classifiers in the realistic setting where a fraction of the data is OOD. Our code is made publicly available at https://github.com/hendrycks/outlier-exposure.
+
+# 2 RELATED WORK
+
+Out-of-Distribution Detection with Deep Networks. Hendrycks & Gimpel (2017) demonstrate that a deep, pre-trained classifier has a lower maximum softmax probability on anomalous examples than in-distribution examples, so a classifier can conveniently double as a consistently useful outof-distribution detector. Building on this work, DeVries & Taylor (2018) attach an auxiliary branch onto a pre-trained classifier and derive a new OOD score from this branch. Liang et al. (2018) present a method which can improve performance of OOD detectors that use a softmax distribution. In particular, they make the maximum softmax probability more discriminative between anomalies and in-distribution examples by pre-processing input data with adversarial perturbations (Goodfellow et al., 2015). Unlike in our work, their parameters are tailored to each source of anomalies.
+
+Lee et al. (2018) train a classifier concurrently with a GAN (Radford et al., 2016; Goodfellow et al., 2014), and the classifier is trained to have lower confidence on GAN samples. For each testing distribution of anomalies, they tune the classifier and GAN using samples from that out-distribution, as discussed in Appendix B of their work. Unlike Liang et al. (2018); Lee et al. (2018), in this work we train our method without tuning parameters to fit specific types of anomaly test distributions, so our results are not directly comparable with their results. Many other works (de Vries et al., 2016; Subramanya et al., 2017; Malinin & Gales, 2018; Bevandic et al., 2018) also encourage the model to have lower confidence on anomalous examples. Recently, Liu et al. (2018) provide theoretical guarantees for detecting out-of-distribution examples under the assumption that a suitably powerful anomaly detector is available.
+
+Utilizing Auxiliary Datasets. Outlier Exposure uses an auxiliary dataset entirely disjoint from test-time data in order to teach the network better representations for anomaly detection. Goodfellow et al. (2015) train on adversarial examples to increased robustness. Salakhutdinov et al. (2011) pre-train unsupervised deep models on a database of web images for stronger features. Radford et al. (2017) train an unsupervised network on a corpus of Amazon reviews for a month in order to obtain quality sentiment representations. Zeiler & Fergus (2014) find that pre-training a network on the large ImageNet database (Russakovsky et al., 2015) endows the network with general representations that are useful in many fine-tuning applications. Chen & Gupta (2015); Mahajan et al. (2018) show that representations learned from images scraped from the nigh unlimited source of search engines and photo-sharing websites improve object detection performance.
+
+# 3 OUTLIER EXPOSURE
+
+We consider the task of deciding whether or not a sample is from a learned distribution called $\mathcal { D } _ { \mathrm { i n } }$ . Samples from $\mathcal { D } _ { \mathrm { i n } }$ are called “in-distribution,” and otherwise are said to be “out-of-distribution” (OOD) or samples from $\mathcal { D } _ { \mathrm { o u t } }$ . In real applications, it may be difficult to know the distribution of outliers one will encounter in advance. Thus, we consider the realistic setting where $\mathcal { D } _ { \mathrm { o u t } }$ is unknfrom Given a parametrized OOD detector and an Outlier Exposure (OE) dataset , we train the model to discover signals and learn heuristics to detect whet $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ , disjoint query is $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ out sampled from $\mathcal { D } _ { \mathrm { i n } }$ or $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ . We find that these heuristics generalize to unseen distributions $\mathcal { D } _ { \mathrm { o u t } }$ .
+
+Deep parametrized anomaly detectors typically leverage learned representations from an auxiliary task, such as classification or density estimation. Given a model $f$ and the original learning objective $\mathcal { L }$ , we can thus formalize Outlier Exposure as minimizing the objective
+
+$$
+\begin{array} { r } { \mathbb { E } _ { ( x , y ) \sim \mathcal { D } _ { \mathrm { i n } } } [ \mathcal { L } ( f ( x ) , y ) + \lambda \mathbb { E } _ { x ^ { \prime } \sim \mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o g } } } [ \mathcal { L } _ { \mathrm { O E } } ( f ( x ^ { \prime } ) , f ( x ) , y ) ] ] } \end{array}
+$$
+
+over the parameters of $f$ . In cases where labeled data is not available, then $y$ can be ignored.
+
+Outlier Exposure can be applied with many types of data and original tasks. Hence, the specific formulation of $\mathcal { L } _ { \mathrm { O E } }$ is a design choice, and depends on the task at hand and the OOD detector used. For example, when using the maximum softmax probability baseline detector (Hendrycks & Gimpel, 2017), we set $\mathcal { L } _ { \mathrm { O E } }$ to the cross-entropy from $f ( x ^ { \prime } )$ to the uniform distribution (Lee et al., 2018). When the original objective $\mathcal { L }$ is density estimation and labels are not available, we set $\mathcal { L } _ { \mathrm { O E } }$ to a margin ranking loss on the log probabilities $f ( x ^ { \prime } )$ and $f ( x )$ .
+
+# 4 EXPERIMENTS
+
+We evaluate OOD detectors with and without OE on a wide range of datasets. Each evaluation consists of an in-distribution dataset $\mathcal { D } _ { \mathrm { i n } }$ used to train an initial model, a dataset of anomalous examples $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ , and a baseline detector to which we apply OE. We describe the datasets in Section 4.2. The OOD detectors and $\mathcal { L } _ { \mathrm { O E } }$ losses are described on a case-by-case basis.
+
+In the first experiment, we show that OE can help detectors generalize to new text and image anomalies. This is all accomplished without assuming access to the test distribution during training or tuning, unlike much previous work. In the confidence branch experiment, we show that OE is flexible and complements a binary anomaly detector. Then we demonstrate that using synthetic outliers does not work as well as using real and diverse data; previously it was assumed that we need synthetic data or carefully selected close-to-distribution data, but real and diverse data is enough. We conclude with experiments in density estimation. In these experiments we find that a cutting-edge density estimator unexpectedly assigns higher density to out-of-distribution samples than in-distribution samples, and we ameliorate this surprising behavior with Outlier Exposure.
+
+# 4.1 EVALUATING OUT-OF-DISTRIBUTION DETECTION METHODS
+
+We evaluate out-of-distribution detection methods on their ability to detect OOD points. For this purpose, we treat the OOD examples as the positive class, and we evaluate three metrics: area under the receiver operating characteristic curve (AUROC), area under the precision-recall curve (AUPR), and the false positive rate at $\bar { N } \%$ true positive rate (FPRN ). The AUROC and AUPR are holistic metrics that summarize the performance of a detection method across multiple thresholds. The AUROC can be thought of as the probability that an anomalous example is given a higher OOD score than a in-distribution example (Davis & Goadrich, 2006). Thus, a higher AUROC is better, and an uninformative detector has an AUROC of $50 \%$ . The AUPR is useful when anomalous examples are infrequent (Manning & Schutze ¨ , 1999), as it takes the base rate of anomalies into account. During evaluation with these metrics, the base rate of $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ to $\mathcal { D } _ { \mathrm { i n } } ^ { \mathrm { t e s t } }$ test examples in all of our experiments is 1:5.
+
+![](images/bc2c3631c797b8ae268766079308e56af29735697fd2d8b21ca900edd4b8ea1e.jpg)  
+Figure 1: ROC curve with Tiny ImageNet $( \mathcal { D } _ { \mathrm { i n } } )$ and Textures $( \mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } } )$ .
+
+Whereas the previous two metrics represent the detection performance across various thresholds, the FPRN metric represents performance at one strict threshold. By observing performance at a strict threshold, we can make clear comparisons among strong detectors. The FPRN metric (Liu et al., 2018; Kumar et al., 2016; Balntas et al., 2016) is the probability that an in-distribution example (negative) raises a false alarm when $N \%$ of anomalous examples (positive) are detected, so a lower FPR $N$ is better. Capturing nearly all anomalies with few false alarms can be of high practical value.
+
+# 4.2 DATASETS
+
+# 4.2.1 IN-DISTRIBUTION DATASETS
+
+SVHN. The SVHN dataset (Netzer et al., 2011) contains $3 2 \times 3 2$ color images of house numbers. There are ten classes comprised of the digits 0-9. The training set has 604, 388 images, and the test set has 26, 032 images. For preprocessing, we rescale the pixels to be in the interval $[ 0 , 1 ]$ .
+
+CIFAR. The two CIFAR (Krizhevsky & Hinton, 2009) datasets contain $3 2 \times 3 \bar { 2 }$ natural color images. CIFAR-10 has ten classes while CIFAR-100 has 100. CIFAR-10 and CIFAR-100 classes are disjoint but have similiarities. For example, CIFAR-10 has “automobiles” and “trucks” but not CIFAR-100’s “pickup truck” class. Both have 50, 000 training images and 10, 000 test images. For this and the remaining image datasets, each image is standardized channel-wise.
+
+Tiny ImageNet. The Tiny ImageNet dataset (Johnson et al.) is a 200-class subset of the ImageNet (Russakovsky et al., 2015) dataset where images are resized and cropped to $6 4 \times 6 4$ resolution. The dataset’s images were cropped using bounding box information so that cropped images contain the target, unlike Downsampled ImageNet (Chrabaszcz et al., 2017). The training set has 100, 000 images and the test set has 10, 000 images.
+
+Places365. The Places365 training dataset (Zhou et al., 2017) consists in 1, 803, 460 large-scale photographs of scenes. Each photograph belongs to one of 365 classes.
+
+20 Newsgroups. 20 Newsgroups is a text classification dataset of newsgroup documents with 20 classes and approximately 20, 000 examples split evenly among the classes. We use the standard 60/40 train/test split.
+
+TREC. TREC is a question classification dataset with 50 fine-grained classes and 5, 952 individual questions. We reserve 500 examples for the test set, and use the rest for training.
+
+SST. The Stanford Sentiment Treebank dataset (Socher et al., 2013) consists of movie reviews expressing positive or negative sentiment. SST has 8, 544 reviews for training and 2, 210 for testing.
+
+# 4.2.2 OUTLIER EXPOSURE DATASETS
+
+80 Million Tiny Images. 80 Million Tiny Images (Torralba et al., 2008) is a large-scale, diverse dataset ofwith SVH $3 2 \times 3 2$ natural images scrapped fAR-10, and CIFAR-100 as the web. We use this dataset as. We remove all examples of 80 $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ for experimentsion Tiny Images in which appear in the CIFAR datasets, so that DOEout and Dtestout are disjoint. In Section 5 we note that
+
+ImageNet-22K. We use the ImageNet dataset with images from approximately 22 thousand classes as too low-re $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ for Tiny Imion. To make et anand aces365 since images from 80 Million Tiny Images areare disjoint, images in ImageNet-1K are removed. $\bar { \mathcal { D } } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$
+
+WikiText-2. WikiText-2 is a corpus of Wikipedia articles typically used for language modeling. We use WikiText-2 as $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ for language modeling experiments with Penn Treebank as $\mathcal { D } _ { \mathrm { i n } }$ . For classification tasks on 20 Newsgroups, TREC, and SST, we treat each sentence of WikiText-2 as an individual example, and use simple filters to remove low-quality sentences.
+
+# 4.3 MULTICLASS CLASSIFICATION
+
+In what follows, we use Outlier Exposure to enhance the performance of existing OOD detection techniques with multiclass classification as the original task. Throughout the following experiments, we let $x \in \mathcal { X }$ be a classifier’s input and $y \in { \mathcal { Y } } = \{ 1 , 2 , \dotsc , \underline { { k } } \}$ be a class. We also represent the classifier with the function $f : \mathcal { X } \overset { } { \to } \mathbb { R } ^ { k }$ , such that for any $x$ , $1 ^ { \top } \bar { f } ( x ) = 1$ and $f ( x ) \succeq 0$ .
+
+Maximum Softmax Probability (MSP). Consider the maximum softmax probability baseline (Hendrycks & Gimpel, 2017) which gives an input $x$ the OOD score $- \operatorname* { m a x } _ { c } f _ { c } ( x )$ . Out-ofdistribution samples are drawn from various unseen distributions (Appendix A). For each task, we test with approximately twice the number of $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ distributions compared to most other papers, and we also test on NLP tasks. The quality of the OOD example scores are judged with the metrics described in Section 4.1. For this multiclass setting, we perform Outlier Exposure by fine-tuning a pre-trained classifier $f$ so that its posterior is more uniform on $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ samples. Specifically, the finetuning objective is $\begin{array} { r } { \mathbb { E } _ { ( x , y ) \sim \mathcal { D } _ { \mathrm { i n } } } [ - \log f _ { y } ( x ) ] + \lambda \mathbb { E } _ { x \sim \mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o g } } } [ H ( \mathcal { U } ; f ( \bar { x } ) ) ] } \end{array}$ , where $H$ is the cross entropy and $\mathcal { U }$ is the uniform distribution over $k$ classes. When there is class imbalance, we could encourage $f ( x )$ to match $( P ( y = 1 ) , \ldots , P ( y = k ) )$ ; yet for the datasets we consider, matching $\mathcal { U }$ works well enough. Also, note that training from scratch with OE can result in even better performance than fine-tuning (Appendix C). This approach works on different architectures as well (Appendix D).
+
+Unlike Liang et al. (2018); Lee et al. (2018) and like Hendrycks & Gimpel (2017); DeVries & Taylor (2018), we do not tune our hyperparameters for each $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ distribution, so that $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ is kept unknown like with real-world anomalies. Instead, the $\lambda$ coefficients were determined early in experimentation with validation $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { v a l } }$ distributions described in Appendix A. In particular, we use $\lambda = 0 . 5$ for vision experiments and $\lambda = 1 . 0$ for NLP experiments. Like previous OOD detection methods involving network fine-tuning, we chose $\lambda$ so that impact on classification accuracy is negligible.
+
+For nearly all of the vision experiments, we train Wide Residual Networks (Zagoruyko & Komodakis, 2016) and then fine-tune network copies with OE for 10 epochs. However we use a pretrained ResNet-18 for Places365. For NLP experiments, we train 2-layer GRUs (Cho et al., 2014) for 5 epochs, then fine-tune network copies with OE for 2 epochs. Networks trained on CIFAR10 or CIFAR-100 are exposed to images from 80 Million Tiny Images, and the Tiny ImageNet and Places365 classifiers are exposed to ImageNet-22K. NLP classifiers are exposed to WikiText-2. Further architectural and training details are in Appendix B. For all tasks, OE improves average performance by a large margin. Averaged results are shown in Tables 1 and 2. Sample ROC curves are shown in Figures 1 and 4. Detailed results on individual $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets are in Table 7 and Table 8 in Appendix A. Notice that the SVHN classifier with OE can be used to detect new anomalies such as emojis and street view alphabet letters, even though $\mathcal { D } _ { \mathrm { O E } } ^ { \mathrm { t e s t } }$ is a dataset of natural images. Thus, Outlier Exposure helps models to generalize to unseen $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ distributions far better than the baseline.
+
+<table><tr><td rowspan="2">Din</td><td colspan="2">FPR95↓</td><td colspan="2">AUROC ↑</td><td colspan="2">AUPR ↑</td></tr><tr><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td></tr><tr><td>SVHN</td><td>6.3</td><td>0.1</td><td>98.0</td><td>100.0</td><td>91.1</td><td>99.9</td></tr><tr><td>CIFAR-10</td><td>34.9</td><td>9.5</td><td>89.3</td><td>97.8</td><td>59.2</td><td>90.5</td></tr><tr><td>CIFAR-100</td><td>62.7</td><td>38.5</td><td>73.1</td><td>87.9</td><td>30.1</td><td>58.2</td></tr><tr><td>Tiny ImageNet</td><td>66.3</td><td>14.0</td><td>64.9</td><td>92.2</td><td>27.2</td><td>79.3</td></tr><tr><td>Places365</td><td>63.5</td><td>28.2</td><td>66.5</td><td>90.6</td><td>33.1</td><td>71.0</td></tr></table>
+
+Table 1: Out-of-distribution image detection for the maximum softmax probability (MSP) baseline detector and the MSP detector after fine-tuning with Outlier Exposure (OE). Results are percentages and also an average of 10 runs. Expanded results are in Appendix A.   
+
+<table><tr><td rowspan="2">Din</td><td colspan="2">FPR90↓</td><td colspan="2">AUROC↑</td><td colspan="2">AUPR↑</td></tr><tr><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td></tr><tr><td>20 Newsgroups</td><td>42.4</td><td>4.9</td><td>82.7</td><td>97.7</td><td>49.9</td><td>91.9</td></tr><tr><td>TREC</td><td>43.5</td><td>0.8</td><td>82.1</td><td>99.3</td><td>52.2</td><td>97.6</td></tr><tr><td>SST</td><td>74.9</td><td>27.3</td><td>61.6</td><td>89.3</td><td>22.9</td><td>59.4</td></tr></table>
+
+Table 2: Comparisons between the MSP baseline and the MSP of the natural language classifier fine-tuned with OE. Results are percentages and averaged over 10 runs.
+
+Confidence Branch. A recently proposed OOD detection technique (DeVries & Taylor, 2018) involves appending an OOD scoring branch $b : \mathcal { X }  [ 0 , 1 ]$ onto a deep network. Trained with samples from only $\mathcal { D } _ { \mathrm { i n } }$ , this branch estimates the network’s confidence on any input. The creators of this technique made their code publicly available, so we use their code to train new 40-4 Wide Residual Network classifiers. We fine-tune the confidence branch with Outlier Exposure by adding $0 . 5 \mathbb { E } _ { \boldsymbol { x } \sim \mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } } } \left[ \log b ( \boldsymbol { x } ) \right]$ to the network’s original optimization objective. In Table 3, the baseline values are derived from the maximum softmax probabilities produced by the classifier trained with DeVries & Taylor (2018)’s publicly available training code. The confidence branch improves over this MSP detector, and after OE, the confidence branch detects anomalies more effectively.
+
+<table><tr><td rowspan="2">Din</td><td colspan="3">FPR95↓</td><td colspan="3">AUROC ↑</td><td colspan="3">AUPR ↑</td></tr><tr><td>MSP</td><td>Branch</td><td>+OE</td><td>MSP</td><td>Branch</td><td>+OE</td><td>MSP</td><td>Branch</td><td>+OE</td></tr><tr><td>CIFAR-10</td><td>49.3</td><td>38.7</td><td>20.8</td><td>84.4</td><td>86.9</td><td>93.7</td><td>51.9</td><td>48.6</td><td>66.6</td></tr><tr><td>CIFAR-100</td><td>55.6</td><td>47.9</td><td>42.0</td><td>77.6</td><td>81.2</td><td>85.5</td><td>36.5</td><td>44.4</td><td>54.7</td></tr><tr><td>Tiny ImageNet</td><td>64.3</td><td>66.9</td><td>20.1</td><td>65.3</td><td>63.4</td><td>90.6</td><td>30.3</td><td>25.7</td><td>75.2</td></tr></table>
+
+Table 3: Comparison among the maximum softmax probability, Confidence Branch, and Confidence Branch $+ \mathrm { { ~ O E ~ } }$ OOD detectors. The same network architecture is used for all three detectors. All results are percentages, and averaged across all $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets.
+
+Synthetic Outliers. Outlier Exposure leverages the simplicity of downloading real datasets, but it is possible to generate synthetic outliers. Note that we made an attempt to distort images with noise and use these as outliers for OE, but the classifier quickly memorized this statistical pattern and did not detect new OOD examples any better than before (Hafner et al., 2018). A method with better success is from Lee et al. (2018). They carefully train a GAN to generate synthetic examples near the classifier’s decision boundary. The classifier is encouraged to have a low maximum softmax probability on these synthetic examples. For CIFAR classifiers, they mention that a GAN can be a better source of anomalies than datasets such as SVHN. In contrast, we find that the simpler approach of drawing anomalies from a diverse dataset is sufficient for marked improvements in OOD detection.
+
+We train a 40-4 Wide Residual Network using Lee et al. (2018)’s publicly available code, and use the network’s maximum softmax probabilities as our baseline. Another classifier trains concurrently with a GAN so that the classifier assigns GAN-generated examples a high OOD score. We want each $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ to be novel. Counters all tested ently we use their code’s default hyperparameters, and distributions. This is unlike their work since, for each ly one modeldistribution, $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ they train and tune a new network. We do not evaluate on Tiny ImageNet, Places365, nor text, since DCGANs cannot stably generate such images and text reliably. Lastly, we take the network trained in tandem with a GAN and fine-tune it with OE. Table 4 shows the large gains from using OE with a real and diverse dataset over using synthetic samples from a GAN.
+
+<table><tr><td rowspan="2">Din</td><td colspan="3">FPR95↓</td><td colspan="3">AUROC ↑</td><td colspan="3">AUPR↑</td></tr><tr><td>MSP</td><td>+GAN</td><td>+OE</td><td>MSP</td><td>+GAN</td><td>+OE</td><td>MSP</td><td>+GAN</td><td>+OE</td></tr><tr><td>CIFAR-10</td><td>32.3</td><td>37.3</td><td>11.8</td><td>88.1</td><td>89.6</td><td>97.2</td><td>51.1</td><td>59.0</td><td>88.5</td></tr><tr><td>CIFAR-100</td><td>66.6</td><td>66.2</td><td>49.0</td><td>67.2</td><td>69.3</td><td>77.9</td><td>27.4</td><td>33.0</td><td>44.7</td></tr></table>
+
+Table 4: Comparison among the maximum softmax probability (MSP), $\mathbf { M S P + G A N }$ , and ${ \mathrm { M S P } } + { }$ $\mathrm { G A N + O E }$ OOD detectors. The same network architecture is used for all three detectors. All results are percentages and averaged across all $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets.
+
+# 4.4 DENSITY ESTIMATION
+
+Density estimators learn a probability density function over the data distribution $\mathcal { D } _ { \mathrm { i n } }$ . Anomalous examples should have low probability density, as they are scarce in $\mathcal { D } _ { \mathrm { i n } }$ by definition (Nalisnick et al., 2019). Consequently, density estimates are another means by which to score anomalies (Zong et al., 2018). We show the ability of OE to improve density estimates on low-probability, outlying data.
+
+$\mathbf { P i x e l C N N + + }$ . Autoregressive neural density estimators provide a way to parametrize the probability density of image data. Although sampling from these architectures is slow, they allow for evaluating the probability density with a single forward pass through a CNN, making them promising candidates for OOD detection. We use Pix${ \mathrm { e l C N N } } { + + }$ (Salimans et al., 2017) as a baseline OOD detector, and we train it on CIFAR-10. The OOD score of example $x$ is the bits per pixel (BPP), defined as ${ \mathrm { n l l } } ( x ) / { \mathrm { n u m } } \_ { \mathrm { p i x e l } \mathrm { s } }$ , where nll is the negative log-likelihood. With this loss we fine-tune for 2 epochs using OE, which we find is sufficient for the training loss to converge. Here OE is implemented with a margin loss over the log-likelihood difference between in-distribution and anomalous examples, so that the loss for a sample $x _ { \mathrm { i n } }$ from $\mathcal { D } _ { \mathrm { i n } }$ and point $x _ { \mathrm { o u t } }$ from $\hat { \mathcal { D } } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ is
+
+![](images/9886df7330693492bd821d7dfaa5aa01cb8f8197ce5c2aa5754a9836e6529f50.jpg)  
+In-Distribution   
+Figure 2: OOD scores from PixelCNN $^ { + + }$ on images from CIFAR-10 and SVHN.
+
+$$
+\mathrm { m a x } \{ 0 , \mathrm { n u m \_ p i x e l s } + \mathrm { n l l } ( x _ { \mathrm { i n } } ) - \mathrm { n l l } ( x _ { \mathrm { o u t } } ) \} .
+$$
+
+Results are shown in Table 5. Notice that PixelCNN++ without OE unexpectedly assigns lower BPP from SVHN images than CIFAR-10 images. For all $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets, OE significantly improves results.
+
+Language Modeling. We next explore using OE on language models. We use QRNN (Merity et al., 2018a;b) language models as baseline OOD detectors. For the OOD score, we use bits per character (BPC) or bits per word (BPW), defined as $\mathrm { n l l } ( x ) / { \mathrm { s } } ,$ equence_length, where $\mathrm { n l l } ( x )$ is the negative log-likelihood of the sequence $x$ . Outlier Exposure is implemented by adding the cross entropy to the uniform distribution on tokens from sequences in $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ as an additional loss term.
+
+For $\mathcal { D } _ { \mathrm { i n } }$ , we convert the language-modeling version of Penn Treebank, split into sequences of length 70 for backpropagation for word-level models, and 150 for character-level models. We do not train or evaluate with preserved hidden states as in BPTT. This is because retaining hidden states would greatly simplify the task of OOD detection. Accordingly, the OOD detection task is to provide a score for 70- or 150-token sequences in the unseen $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets.
+
+Table 5: OOD detection results with a $\mathrm { P i x e l C N N + + }$ density estimator, and the same estimator after applying OE. The model’s bits per pixel (BPP) scores each sample. All results are percentages. Test distributions $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ are described in Appendix A.   
+
+<table><tr><td colspan="2"></td><td colspan="2">FPR95↓</td><td colspan="2">AUROC ↑</td><td colspan="2">AUPR ↑</td></tr><tr><td>Din</td><td>Dtest out</td><td>BPP</td><td>+OE</td><td>BPP</td><td>+OE</td><td>BPP</td><td>+OE</td></tr><tr><td rowspan="9">CIFAR-10</td><td>Gaussian</td><td>0.0</td><td>0.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>99.6</td></tr><tr><td>Rademacher</td><td>61.4</td><td>50.3</td><td>44.2</td><td>56.5</td><td>14.2</td><td>17.3</td></tr><tr><td>Blobs</td><td>17.2</td><td>1.3</td><td>93.2</td><td>99.5</td><td>60.0</td><td>96.2</td></tr><tr><td>Textures</td><td>96.8</td><td>48.9</td><td>69.4</td><td>88.8</td><td>40.9</td><td>70.0</td></tr><tr><td>SVHN</td><td>98.8</td><td>86.9</td><td>15.8</td><td>75.8</td><td>9.7</td><td>60.0</td></tr><tr><td>Places365</td><td>86.1</td><td>50.3</td><td>74.8</td><td>89.3</td><td>38.6</td><td>70.4</td></tr><tr><td>LSUN</td><td>76.9</td><td>43.2</td><td>76.4</td><td>90.9</td><td>36.5</td><td>72.4</td></tr><tr><td>CIFAR-100</td><td>96.1</td><td>89.8</td><td>52.4</td><td>68.5</td><td>19.0</td><td>41.9</td></tr><tr><td>Mean</td><td>66.6</td><td>46.4</td><td>65.8</td><td>83.7</td><td>39.9</td><td>66.0</td></tr></table>
+
+We train word-level models for 300 epochs, and character-level models for 50 epochs. We then fine-tune using OE on WikiText-2 for 5 epochs. For the character-level language model, we create a character-level version of WikiText-2 by converting words to lowercase and leaving out characters which do not appear in PTB. OOD detection results for the word-level and character-level language models are shown in Table 6; expanded results and $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ descriptions are in Appendix F. In all cases, OE improves over the baseline, and the improvement is especially large for the word-level model.
+
+<table><tr><td rowspan="2">Din</td><td colspan="2">FPR90↓</td><td colspan="2">AUROC ↑</td><td colspan="2">AUPR↑</td></tr><tr><td>BPC/BPW</td><td>+OE</td><td>BPC/BPW</td><td>+OE</td><td>BPC/BPW</td><td>+OE</td></tr><tr><td>PTB Characters</td><td>99.0</td><td>89.4</td><td>77.5</td><td>86.3</td><td>76.0</td><td>86.7</td></tr><tr><td>PTB Words</td><td>48.5</td><td>0.98</td><td>81.2</td><td>99.2</td><td>44.0</td><td>97.8</td></tr></table>
+
+Table 6: OOD detection results on Penn Treebank language models. Results are percentages averaged over the $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets. Expanded results are in Appendix F.
+
+# 5 DISCUSSION
+
+Extensions to Multilabel Classifiers and the Reject Option. Outlier Exposure can work in more classification regimes than just those considered above. For example, a multilabel classifier trained on CIFAR-10 obtains an $8 8 . 8 \%$ mean AUROC when using the maximum prediction probability as the OOD score. By training with OE to decrease the classifier’s output probabilities on OOD samples, the mean AUROC increases to $9 7 . 1 \%$ . This is slightly less than the AUROC for a multiclass model tuned with OE. An alternative OOD detection formulation is to give classifiers a “reject class” (Bartlett & Wegkamp, 2008). Outlier Exposure is also flexible enough to improve performance in this setting, but we find that even with OE, classifiers with the reject option or multilabel outputs are not as competitive as OOD detectors with multiclass outputs.
+
+Flexibility in Choosing tant for generalization to $\mathcal { D } _ { \mathbf { o u t } } ^ { \mathbf { o E } }$ . een in experimentation, we found that the choice of distributions. For example, adding Gaussian no $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ is impor-o samples $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$   
+from $\mathcal { D } _ { \mathrm { i n } }$ to create $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ does not teach the network to generalize to unseen anomaly distributions for   
+complex $\mathcal { D } _ { \mathrm { i n } }$ . Similarly, we found in Section 4.3 that synthetic anomalies do not work as well as real   
+data for describe $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ . In contrast, our experiments demonSection 4.2.2 do generalize to unseen that the large datasets of realistic anomaliesdistributions. $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$
+
+In addition to size and realism, we founCIFAR-100 classifier with CIFAR-10 as ersity of hardly i $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ to be an important factor. Concretely, aves over the baseline. A CIFAR-10 clas$\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ sifier exposed to ten CIFAR-100 outlier classes corresponds to an average AUPR of $78 . 5 \%$ . Exposed to 30 such classes, the classifier’s average AUPR becomes $8 5 . 1 \%$ . Next, 50 classes corresponds to $8 5 . 3 \%$ , and from thereon additional CIFAR-100 classes barely improve performance. This suggests that dataset diversity is important, not just size. In fact, experiments in this paper often used around
+
+$1 \%$ of the images in the 80 Million Tiny Images dataset since we only briefly fine-tuned the models. We also found that using only 50,000 examples from this dataset led to a negligible degradation in detection performance. Additionally, $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ datasets with significantly different statistics can perform out similarly. For instance, using the Project Gutenberg dataset in lieu of WikiText-2 for $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o b } }$ i n the SST experiments gives an average AUROC of $9 0 . 1 \%$ instead of $8 9 . 3 \%$ .
+
+Closeness of Dtest, DOE, out and Dtestin . Our experiments show several interesting effects of the closeness of the datasets involved. Firstly, we find that $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ and $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ need not be close for training with OE to improve performance on $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ . In Appendix A, we observe that an OOD detector for SVHN has its performance improve with Ouural scenes rather than digits, and (2) Exposure even though (1)  includes unnatural examp $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ samples are images of nat-uch as emojis. We observed $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$   
+out the same in our preliminary experiments with MNIST; using 80 Million Tiny Images as $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ , O E increased the AUPR from $9 4 . 2 \%$ to $9 7 . 0 \%$ . Secondly, we find that the closeness of OE. In the NLP experiments, preproces $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ $\mathcal { D } _ { \mathrm { i n } } ^ { \mathrm { t e s t } }$ can be ane closer to ortant factor in the success ofimproves OOD detection per$\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ $\mathcal { D } _ { \mathrm { i n } }$   
+formance significantly. Without preprocessing, the network may discover easy-to-learn cues which reveal whether the input is in- or out-of-distribution, so the OE training objective can be optimized in unintended ways. That results in weaker detectors. In a separate experiment, we use Online Hard Example Mining so that difficult outliers have more weight in Outlier Exposure. Although this improves performance on the hardest anomalies, anomalies without plausible local statistics like noise are detected slightly less effectively than before. Thus hard or close-to-distribution examples do not necessarily teach the detector all valuable heuristics for detecting various forms of anomalies. Real-world applications of OE could use the method of Sun et al. (2018) to refine a scraped $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ auxiliary dataset to be appropriately close to $\mathcal { D } _ { \mathrm { i n } } ^ { \mathrm { t e s t } }$ .
+
+OE Improves Calibration. When using classifiers for prediction, it is important that confidence estimates given for the predictions do not misrepresent empirical performance. A calibrated classifier gives confidence probabilities that match the empirical frequency of correctness. That is, if a calibrated model predicts an event with $30 \%$ probability, then $30 \%$ of the time the event transpires.
+
+Existing confidence calibration approaches consider the standard setting where data at test-time is always drawn from $\mathcal { D } _ { \mathrm { i n } }$ . We extend this setting to include examples from $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ at test-time since systems should provide calibrated probabilities on both in- and out-of-distribution samples. The classifier should have low-confidence predictions on these OOD examples, since they do not have a class. Building on the temperature tuning method of Guo et al. (2017), we demonstrate that
+
+![](images/645c96fa99de12ec7263cb7a61ef1cac6d364540804bf923b6d462b1380c451f.jpg)  
+Figure 3: Root Mean Square Calibration Error values with temperature tuning and temperature tuning $+ \mathrm { O E }$ across various datasets.
+
+OE can improve calibration performance in this realistic setting. Summary results are shown in Figure 3. Detailed results and a description of the metrics are in Appendix G.
+
+# 6 CONCLUSION
+
+In this paper, we proposed Outlier Exposure, a simple technique that enhances many current OOD detectors across various settings. It uses out-of-distribution samples to teach a network heuristics to detect new, unmodeled, out-of-distribution examples. We showed that this method is broadly applicable in vision and natural language settings, even for large-scale image tasks. OE can improve model calibration and several previous anomaly detection techniques. Further, OE can teach density estimation models to assign more plausible densities to out-of-distribution samples. Finally, Outlier Exposure is computationally inexpensive, and it can be applied with low overhead to existing systems. In summary, Outlier Exposure is an effective and complementary approach for enhancing out-of-distribution detection systems.
+
+# ACKNOWLEDGMENTS
+
+We thank NVIDIA for donating GPUs used in this research. This research was supported by a grant from the Future of Life Institute.
+
+# REFERENCES
+
+Vassileios Balntas, Edgar Riba, Daniel Ponsa, and Krystian Mikolajczyk. Learning local feature descriptors with triplets and shallow convolutional neural networks. British Machine Vision Conference, 2016.
+
+Peter L Bartlett and Marten H Wegkamp. Classification with a reject option using a hinge loss. Journal of Machine Learning Research, 2008.
+
+Petra Bevandic, Sinisa Segvic, Ivan Kreso, and Marin Orsic. Discriminative out-of-distribution detection for semantic segmentation. arXiv preprint, 2018.
+
+Ann Bies, Justin Mott, Colin Warner, and Seth Kulick. English web treebank, 2012.
+
+Xinlei Chen and Abhinav Gupta. Webly supervised learning of convolutional networks. In International Conference on Computer Vision, 2015.
+
+Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. Empirical Methods in Natural Language Processing, 2014.
+
+Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the cifar datasets. arXiv preprint, 2017.
+
+Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi. Describing textures in the wild. Computer Vision and Pattern Recognition, 2014.
+
+Jesse Davis and Mark Goadrich. The relationship between precision-recall and ROC curves. In International Conference on Machine Learning, 2006.
+
+Harm de Vries, Roland Memisevic, and Aaron Courville. Deep learning vector quantization. In European Symposium on Artificial Neural Networks, Computational Intelligence and Machine Learning, 2016.
+
+Terrance DeVries and Graham W Taylor. Learning confidence for out-of-distribution detection in neural networks. arXiv preprint arXiv:1802.04865, 2018.
+
+Andrew F Emmott, Shubhomoy Das, Thomas Dietterich, Alan Fern, and Weng-Keen Wong. Systematic construction of anomaly detection benchmarks from real data. In Proceedings of the ACM SIGKDD workshop on outlier detection and description. ACM, 2013.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. Neural Information Processing Systems, 2014.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Machine Learning, 2015.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q. Weinberger. On calibration of modern neural networks. International Conference on Machine Learning, 2017.
+
+Danijar Hafner, Dustin Tran, Alex Irpan, Timothy Lillicrap, and James Davidson. Reliable uncertainty estimates in deep neural networks using noise contrastive priors. International Conference on Machine Learning Workshop, 2018.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. International Conference on Learning Representations, 2019.
+
+Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. International Conference on Learning Representations, 2017.
+
+Johnson et al. Tiny imagenet visual recognition challenge. URL https://tiny-imagenet. herokuapp.com.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. Neural Information Processing Systems, 2012.
+
+Volodymyr Kuleshov and Percy Liang. Calibrated structured prediction. Neural Information Processing Systems, 2015.
+
+Vijay Kumar, Gustavo Carneiro, and Ian Reid. Learning local image descriptors with deep siamese and triplet convolutional networks by minimizing global loss functions. Computer Vision and Pattern Recognition, 2016.
+
+Kimin Lee, Honglak Lee, Kibok Lee, and Jinwoo Shin. Training confidence-calibrated classifiers for detecting out-of-distribution samples. International Conference on Learning Representations, 2018.
+
+Shiyu Liang, Yixuan Li, and R. Srikant. Enhancing the reliability of out-of-distribution image detection in neural networks. International Conference on Learning Representations, 2018.
+
+Si Liu, Risheek Garrepalli, Thomas Dietterich, Alan Fern, and Dan Hendrycks. Open category detection with PAC guarantees. In Proceedings of International Conference on Machine Learning, 2018.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts, 2017.
+
+Dhruv Mahajan, Ross Girshick, Vignesh Ramanathan, Kaiming He, Manohar Paluri, Yixuan Li, Ashwin Bharambe, and Laurens van der Maaten. Exploring the limits of weakly supervised pretraining. arXiv preprint, 2018.
+
+Andrey Malinin and Mark Gales. Predictive uncertainty estimation via prior networks. Neural Information Processing Systems, 2018.
+
+Chris Manning and Hinrich Schutze. ¨ Foundations of Statistical Natural Language Processing. MIT Press, 1999.
+
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and Optimizing LSTM Language Models. International Conference on Learning Representations, 2018a.
+
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. An Analysis of Neural Language Modeling at Multiple Scales. arXiv preprint, 2018b.
+
+Eric Nalisnick, Akihiro Matsukawa, Yee Whye Teh, Dilan Gorur, and Balaji Lakshminarayanan. Do deep generative models know what they don’t know? International Conference on Learning Representations, 2019.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011.
+
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In Computer Vision and Pattern Recognition, 2015.
+
+Khanh Nguyen and Brendan O’Connor. Posterior calibration and exploratory analysis for natural language processing models. Empirical Methods in Natural Language Processing, 2015.
+
+Joan Pastor-Pellicer, Francisco Zamora-Mart´ınez, Salvador Espana-Boquera, and Mar ˜ ´ıa Jose Castro- ´ Bleda. F-measure as the error function to train neural networks. In International Work-Conference on Artificial Neural Networks (IWANN), 2013.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. International Conference on Machine Learning, 2016.
+
+Alec Radford, Rafal Jozefowicz, and Ilya Sutskever. Learning to generate reviews and discovering sentiment. arXiv preprint, 2017.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 2015.
+
+Ruslan Salakhutdinov, Joshua Tenenbaum, and Antonio Torralba. Learning to learn with compound hd models. In Neural Information Processing Systems, 2011.
+
+Tim Salimans and Diederik Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. NIPS, 2016.
+
+Tim Salimans, Andrej Karpathy, Xi Chen, and Diederik P Kingma. PixelCNN $^ { + + }$ : Improving the PixelCNN with discretized logistic mixture likelihood and other modifications. International Conference on Learning Representations, 2017.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher Manning, Andrew $\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Conference on Empirical Methods in Natural Language Processing, 2013.
+
+Akshayvarun Subramanya, Suraj Srinivas, and R.Venkatesh Babu. Confidence estimation in deep neural networks via density modelling. arXiv preprint, 2017.
+
+Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. Large scale fine-grained categorization and the effectiveness of domain-specific transfer learning. Yin Cui and Yang Song and Chen Sun and Andrew Howard and Serge Belongie, 2018.
+
+Antonio Torralba, Rob Fergus, and William T Freeman. 80 million tiny images: A large data set for nonparametric object and scene recognition. Pattern Analysis and Machine Intelligence, 2008.
+
+Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. LSUN: construction of a large-scale image dataset using deep learning with humans in the loop. CoRR, 2015.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. British Machine Vision Conference, 2016.
+
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European Conference on Computer Vision. Springer, 2014.
+
+Bolei Zhou, Agata Lapedriza, Aditya Khosla, Aude Oliva, and Antonio Torralba. Places: A 10 million image database for scene recognition. Pattern Analysis and Machine Intelligence, 2017.
+
+Bo Zong, Qi Song, Martin Renqiang Min, Wei Cheng, Cristian Lumezanu, Daeki Cho, and Haifeng Chen. Deep autoencoding gaussian mixture model for unsupervised anomaly detection. International Conference on Learning Representations, 2018.
+
+# A EXPANDED MULTICLASS RESULTS
+
+Expanded mutliclass out-of-distribution detection results are in Table 7 and Table 8.   
+Table 7: Vision OOD example detection for the maximum softmax probability (MSP) baseline detector and the MSP detector after fine-tuning with Outlier Exposure (OE). All results are percentages and the result of 10 runs. Values are rounded so that $9 9 . 9 5 \%$ rounds to $1 0 0 \%$ . More results are in Appendix E.   
+
+<table><tr><td colspan="2"></td><td colspan="2">FPR95↓</td><td colspan="2">AUROC ↑</td><td colspan="2">AUPR ↑</td></tr><tr><td>Din</td><td>Dest</td><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td></tr><tr><td rowspan="11">NH∧S</td><td>Gaussian Bernoulli</td><td>5.4</td><td>0.0</td><td>98.2</td><td>100.</td><td>90.5</td><td>100.</td></tr><tr><td></td><td>4.4</td><td>0.0</td><td>98.6</td><td>100.</td><td>91.9</td><td>100.</td></tr><tr><td>Blobs</td><td>3.7</td><td>0.0</td><td>98.9</td><td>100.</td><td>93.5</td><td>100.</td></tr><tr><td>Icons-50</td><td>11.4</td><td>0.3</td><td>96.4</td><td>99.8</td><td>87.2</td><td>99.2</td></tr><tr><td>Textures</td><td>7.2</td><td>0.2</td><td>97.5</td><td>100.</td><td>90.9</td><td>99.7</td></tr><tr><td>Places365</td><td>5.6</td><td>0.1</td><td>98.1</td><td>100.</td><td>92.5</td><td>99.9</td></tr><tr><td>LSUN</td><td>6.4</td><td>0.1</td><td>97.8</td><td>100.</td><td>91.0</td><td>99.9</td></tr><tr><td>CIFAR-10</td><td>6.0</td><td>0.1</td><td>98.0</td><td>100.</td><td>91.2</td><td>99.9</td></tr><tr><td>Chars74K</td><td>6.4</td><td>0.1</td><td>97.9</td><td>100.</td><td>91.5</td><td>99.9</td></tr><tr><td>Mean</td><td>6.28</td><td>0.07</td><td>97.95</td><td>99.96</td><td>91.12</td><td>99.85</td></tr><tr><td rowspan="8">CIAAIII0</td><td>Gaussian</td><td>14.4</td><td>0.7</td><td>94.7</td><td>99.6</td><td>70.0</td><td>94.3</td></tr><tr><td>Rademacher</td><td>47.6</td><td>0.5</td><td>79.9</td><td>99.8</td><td>32.3</td><td>97.4</td></tr><tr><td>Blobs</td><td>16.2</td><td>0.6</td><td>94.5</td><td>99.8</td><td>73.7</td><td>98.9</td></tr><tr><td>Textures</td><td>42.8</td><td>12.2</td><td>88.4</td><td>97.7</td><td>58.4</td><td>91.0</td></tr><tr><td>SVHN</td><td>28.8</td><td>4.8</td><td>91.8</td><td>98.4</td><td>66.9</td><td>89.4</td></tr><tr><td>Places365</td><td>47.5</td><td>17.3</td><td>87.8</td><td>96.2</td><td>57.5</td><td>87.3</td></tr><tr><td>LSUN</td><td>38.7</td><td>12.1</td><td>89.1</td><td>97.6</td><td>58.6</td><td>89.4</td></tr><tr><td>CIFAR-100</td><td>43.5</td><td>28.0</td><td>87.9</td><td>93.3</td><td>55.8</td><td>76.2</td></tr><tr><td></td><td>Mean</td><td>34.94</td><td>9.50</td><td>89.27</td><td>97.81</td><td>59.16</td><td>90.48</td></tr><tr><td rowspan="11">CII-AIII0</td><td>Gaussian</td><td>54.3</td><td>12.1</td><td>64.7</td><td>95.7</td><td>19.7</td><td>71.1</td></tr><tr><td>Rademacher</td><td>39.0</td><td>17.1</td><td>79.4</td><td>93.0</td><td>30.1</td><td>56.9</td></tr><tr><td>Blobs</td><td>58.0</td><td>12.1</td><td>75.3</td><td>97.2</td><td>29.7</td><td>86.2</td></tr><tr><td>Textures</td><td>71.5</td><td>54.4</td><td>73.8</td><td>84.8</td><td>33.3</td><td>56.3</td></tr><tr><td>SVHN</td><td>69.3</td><td>42.9</td><td>71.4</td><td>86.9</td><td>30.7</td><td>52.9</td></tr><tr><td>Places365</td><td>70.4</td><td>49.8</td><td>74.2</td><td>86.5</td><td>33.8</td><td>57.9</td></tr><tr><td>LSUN</td><td>74.0</td><td>57.5</td><td>70.7</td><td>83.4</td><td>28.8</td><td>51.4</td></tr><tr><td>CIFAR-10</td><td>64.9</td><td>62.1</td><td>75.4</td><td>75.7</td><td>34.3</td><td>32.6</td></tr><tr><td>Mean</td><td>62.66</td><td>38.50</td><td>73.11</td><td>87.89</td><td>30.05</td><td>58.15</td></tr><tr><td>Gaussian</td><td>72.6</td><td>45.4</td><td>33.7</td><td>76.5</td><td>12.3</td><td>28.6</td></tr><tr><td rowspan="8">1hrree Gi</td><td>Rademacher</td><td>51.7</td><td>49.0</td><td>62.0</td><td>65.1</td><td>18.8</td><td>20.0</td></tr><tr><td>Blobs</td><td>79.4</td><td>0.0</td><td>48.2</td><td>100.</td><td>14.4</td><td>99.9</td></tr><tr><td>Textures</td><td>76.4</td><td>4.8</td><td>70.4</td><td>98.5</td><td>31.4</td><td>95.8</td></tr><tr><td>SVHN</td><td>52.3</td><td>0.4</td><td>80.8</td><td>99.8</td><td>42.8</td><td>98.2</td></tr><tr><td>Places365</td><td>63.6</td><td>0.4</td><td>76.9</td><td>99.8</td><td>36.3</td><td>99.3</td></tr><tr><td>LSUN</td><td>67.0</td><td>0.4</td><td>74.2</td><td>99.9</td><td>31.2</td><td>99.5</td></tr><tr><td>ImageNet</td><td>67.3</td><td>11.6</td><td>72.8</td><td>97.9</td><td>30.0</td><td>92.9</td></tr><tr><td>Mean</td><td>66.27</td><td>13.99</td><td>64.86</td><td>92.18</td><td>27.15</td><td>79.26</td></tr><tr><td rowspan="11">Psse55</td><td>Gaussian</td><td>37.1</td><td></td><td></td><td>93.5</td><td></td><td></td></tr><tr><td>Rademacher</td><td>60.4</td><td>9.4 13.5</td><td>72.2 47.7</td><td>90.2</td><td>23.5 14.6</td><td>54.1 44.9</td></tr><tr><td>Blobs</td><td>73.7</td><td>0.1</td><td>41.9</td><td>100.0</td><td>13.0</td><td>99.4</td></tr><tr><td>Icons-50</td><td>59.1</td><td>0.0</td><td>82.7</td><td>99.9</td><td>49.9</td><td>99.7</td></tr><tr><td>Textures</td><td>84.1</td><td></td><td>66.6</td><td>91.4</td><td>24.6</td><td>75.7</td></tr><tr><td></td><td></td><td>49.9</td><td></td><td></td><td></td><td></td></tr><tr><td>SVHN</td><td>19.9</td><td>0.0 65.3</td><td>96.6</td><td>100.0</td><td>90.5</td><td>99.9</td></tr><tr><td>ImageNet Places69</td><td></td><td>86.3 87.3</td><td>63.0</td><td>86.5</td><td>25.1</td><td>69.7</td></tr><tr><td></td><td></td><td>87.5</td><td>61.5</td><td>63.1</td><td>23.4</td><td>24.9</td></tr><tr><td>Mean</td><td></td><td>28.21</td><td>66.51</td><td>90.57</td><td>33.08</td><td>71.04</td></tr><tr><td></td><td>63.46</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 8: NLP OOD example detection for the maximum softmax probability (MSP) baseline detector and the MSP detector after fine-tuning with Outlier Exposure (OE). All results are percentages and the result of 10 runs. Values are rounded so that $9 9 . 9 5 \%$ rounds to $1 0 0 \%$ .   
+
+<table><tr><td rowspan=2 colspan=4>FPR90↓               AUROC ↑                AUPR ↑Din   Dtest              MSP       +OE       MSP       +OE       MSP       +OEout</td></tr><tr><td rowspan=1 colspan=1>MSP       +OE</td><td rowspan=1 colspan=1>MSP       +OE</td><td rowspan=1 colspan=1>MSP       +OE</td></tr><tr><td rowspan=1 colspan=1>SNLI</td><td rowspan=1 colspan=1>38.2        12.5</td><td rowspan=1 colspan=1>87.7       95.1</td><td rowspan=1 colspan=1>71.3       86.3</td></tr><tr><td rowspan=1 colspan=1>IMDB</td><td rowspan=1 colspan=1>45.0        18.6</td><td rowspan=1 colspan=1>79.9       93.5</td><td rowspan=1 colspan=1>42.6       74.5</td></tr><tr><td rowspan=1 colspan=1>Multi30K</td><td rowspan=1 colspan=1>54.5        3.2</td><td rowspan=1 colspan=1>78.3       97.3</td><td rowspan=1 colspan=1>45.8       93.7</td></tr><tr><td rowspan=1 colspan=1>WMT16</td><td rowspan=1 colspan=1>45.8        2.0</td><td rowspan=1 colspan=1>80.2       98.8</td><td rowspan=1 colspan=1>43.7       96.1</td></tr><tr><td rowspan=1 colspan=1>Yelp</td><td rowspan=1 colspan=1>45.9        3.9</td><td rowspan=1 colspan=1>78.7       97.8</td><td rowspan=1 colspan=1>38.1       87.9</td></tr><tr><td rowspan=1 colspan=1>EWT-A</td><td rowspan=1 colspan=1>36.1        1.2</td><td rowspan=1 colspan=1>86.2       99.2</td><td rowspan=1 colspan=1>58.2       97.3</td></tr><tr><td rowspan=2 colspan=1>EWT-EEWT-N</td><td rowspan=1 colspan=1>31.9        1.4</td><td rowspan=1 colspan=1>87.8       99.2</td><td rowspan=1 colspan=1>60.3       97.2</td></tr><tr><td rowspan=1 colspan=1>41.7        1.8</td><td rowspan=1 colspan=1>83.1       98.7</td><td rowspan=1 colspan=1>46.2       95.7</td></tr><tr><td rowspan=1 colspan=1>EWT-R</td><td rowspan=1 colspan=1>40.7        1.7</td><td rowspan=1 colspan=1>83.5       98.9</td><td rowspan=1 colspan=1>53.4       96.6</td></tr><tr><td rowspan=1 colspan=1>EWT-W</td><td rowspan=1 colspan=1>44.5        2.4</td><td rowspan=1 colspan=1>81.1       98.5</td><td rowspan=1 colspan=1>39.0       93.8</td></tr><tr><td rowspan=1 colspan=1>Mean</td><td rowspan=1 colspan=1>42.44       4.86</td><td rowspan=1 colspan=1>82.66      97.71</td><td rowspan=1 colspan=1>49.85      91.91</td></tr><tr><td rowspan=1 colspan=1>SNLI</td><td rowspan=1 colspan=1>18.2        4.2</td><td rowspan=1 colspan=1>94.0       98.1</td><td rowspan=1 colspan=1>81.9       91.6</td></tr><tr><td rowspan=1 colspan=1>IMDB</td><td rowspan=1 colspan=1>49.6        0.6</td><td rowspan=1 colspan=1>78.0       99.4</td><td rowspan=1 colspan=1>44.2       97.8</td></tr><tr><td rowspan=3 colspan=1>Multi30KWMT16TTTE     Yelp</td><td rowspan=1 colspan=1>44.2        0.3</td><td rowspan=1 colspan=1>81.6       99.7</td><td rowspan=1 colspan=1>44.9        99.0</td></tr><tr><td rowspan=1 colspan=1>50.7        0.2</td><td rowspan=1 colspan=1>78.2       99.8</td><td rowspan=1 colspan=1>42.2        99.4</td></tr><tr><td rowspan=1 colspan=1>50.9        0.4</td><td rowspan=1 colspan=1>75.1       99.7</td><td rowspan=1 colspan=1>37.7        96.1</td></tr><tr><td rowspan=5 colspan=1>TTTE     EWT-AEWT-EEWT-NEWT-REWT-W</td><td rowspan=1 colspan=1>45.7        0.9</td><td rowspan=1 colspan=1>82.4       97.7</td><td rowspan=1 colspan=1>53.1        96.1</td></tr><tr><td rowspan=1 colspan=1>36.8        0.4</td><td rowspan=1 colspan=1>85.7       99.5</td><td rowspan=1 colspan=1>60.8        99.1</td></tr><tr><td rowspan=1 colspan=1>44.3        0.3</td><td rowspan=1 colspan=1>84.2       99.6</td><td rowspan=1 colspan=1>58.8        99.2</td></tr><tr><td rowspan=1 colspan=1>46.1        0.4</td><td rowspan=1 colspan=1>82.5       99.5</td><td rowspan=1 colspan=1>51.1       98.8</td></tr><tr><td rowspan=1 colspan=1>50.1        0.2</td><td rowspan=1 colspan=1>79.8       99.7</td><td rowspan=1 colspan=1>47.8       99.4</td></tr><tr><td rowspan=1 colspan=1>Mean</td><td rowspan=1 colspan=1>43.46       0.78</td><td rowspan=1 colspan=1>82.14      99.28</td><td rowspan=1 colspan=1>52.23      97.64</td></tr><tr><td rowspan=1 colspan=1>SNLI</td><td rowspan=1 colspan=1>57.3        33.4</td><td rowspan=1 colspan=1>75.7       86.8</td><td rowspan=1 colspan=1>36.2       52.0</td></tr><tr><td rowspan=1 colspan=1>IMDB</td><td rowspan=1 colspan=1>83.1        32.6</td><td rowspan=1 colspan=1>54.3        85.9</td><td rowspan=1 colspan=1>19.0       51.5</td></tr><tr><td rowspan=2 colspan=1>Multi30KWMT16</td><td rowspan=1 colspan=1>81.3       33.0</td><td rowspan=1 colspan=1>58.5       88.3</td><td rowspan=1 colspan=1>21.4        58.9</td></tr><tr><td rowspan=1 colspan=1>76.0        17.1</td><td rowspan=1 colspan=1>60.2       92.9</td><td rowspan=1 colspan=1>21.4        68.8</td></tr><tr><td rowspan=2 colspan=1>S     YelpEWT-A</td><td rowspan=1 colspan=1>82.0        11.3</td><td rowspan=1 colspan=1>54.2       92.7</td><td rowspan=1 colspan=1>18.8        60.0</td></tr><tr><td rowspan=1 colspan=1>72.6       33.6</td><td rowspan=1 colspan=1>62.7       87.2</td><td rowspan=1 colspan=1>21.4        53.8</td></tr><tr><td rowspan=4 colspan=1>EWT-EEWT-NEWT-REWT-W</td><td rowspan=1 colspan=1>68.1        26.5</td><td rowspan=1 colspan=1>68.5       90.4</td><td rowspan=1 colspan=1>27.0        63.7</td></tr><tr><td rowspan=1 colspan=1>73.8        27.2</td><td rowspan=1 colspan=1>63.8        90.1</td><td rowspan=1 colspan=1>22.6        62.0</td></tr><tr><td rowspan=1 colspan=1>79.6       41.4</td><td rowspan=1 colspan=1>58.1       85.6</td><td rowspan=1 colspan=1>20.3       54.7</td></tr><tr><td rowspan=1 colspan=1>74.8       17.2</td><td rowspan=1 colspan=1>60.3       92.8</td><td rowspan=1 colspan=1>21.2       66.9</td></tr><tr><td rowspan=1 colspan=1>Mean</td><td rowspan=1 colspan=1>74.86      25.31</td><td rowspan=1 colspan=1>61.61      90.07</td><td rowspan=1 colspan=1>22.93      64.37</td></tr></table>
+
+Anomalous Data. For each in-distribution dataset $\mathcal { D } _ { \mathrm { i n } }$ , we comprehensively evaluate OOD detectors on artificial and real anomalous distributions $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ following Hendrycks & Gimpel (2017). For each learned distribution $\mathcal { D } _ { \mathrm { i n } }$ , the number of test distributions that we compare against is approximately double that of most previous works.
+
+Gaussian anomalies have each dimension i.i.d. sampled from an isotropic Gaussian distribution. Rademacher anomalies are images where each dimension is $- 1$ or 1 with equal probability, so each dimension is sampled from a symmetric Rademacher distribution. Bernoulli images have each pixel sampled from a Bernoulli distribution if the input range is [0, 1]. Blobs data consist in algorithmically generated amorphous shapes with definite edges. Icons- $5 0$ is a dataset of icons and emojis (Hendrycks & Dietterich, 2019); icons from the “Number” class are removed. Textures is a dataset of describable textural images (Cimpoi et al., 2014). Places365 consists in images for scene recognition rather than object recognition (Zhou et al., 2017). LSUN is another scene understanding dataset with fewer classes than Places365 (Yu et al., 2015). ImageNet anomalous examples are taken from the 800 ImageNet-1K classes disjoint from Tiny ImageNet’s 200 classes, and when possible each image is cropped with bounding box information as in Tiny ImageNet. For the Places365 experiment, ImageNet is ImageNet-1K with all 1000 classes. With CIFAR-10 as $\mathcal { D } _ { \mathrm { i n } }$ , we use also CIFAR-100 as $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ and vice versa; recall that the CIFAR-10 and CIFAR-100 classes do not overlap. Chars74K is a dataset of photographed characters in various styles; digits and letters such as “O” and “l” were removed since they can look like numbers. Places69 has images from 69 scene categories not found in the Places365 dataset.
+
+SNLI is a dataset of predicates and hypotheses for natural language inference. We use the hypotheses for $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ . IMDB is a sentiment classification dataset of movie reviews, with similar statistics to those of SST. Multi30K is a dataset of English-German image descriptions, of which we use the English descriptions. WMT16 is the English portion of the test set from WMT16. Yelp is a dataset of restaurant reviews. English Web Treebank (EWT) consists of five individual datasets: Answers (A), Email (E), Newsgroups (N), Reviews (R), and Weblog (W). Each contains examples from the indicated domain.
+
+Validation Data. For each experiment, we create a set of validation distributions $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { v a l } }$ . The first anomalies are uniform noise anomalies where each pixel is sampled from $\boldsymbol { \mathcal { U } } [ 0 , 1 ]$ or $\mathcal { U } [ - 1 , 1 ]$ depending on the input space of the classifier. The remaining $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { v a l } }$ validation sources are generated by corrupting in-distribution data, so that the data becomes out-of-distribution. One such source of anomalies is created by taking the pixelwise arithmetic mean of a random pair of in-distribution images. Other anomalies are created by taking the geometric mean of a random pair of in-distribution images. Jigsaw anomalies are created by taking an in-distribution example, partitioning the image into 16 equally sized patches, and permuting those patches. Speckle Noised anomalies are created by applying speckle noise to in-distribution images. RGB Ghosted anomalies involves shifting and reordering the color channels of in-distribution images. Inverted images are anomalies which have some or all of their color channels inverted.
+
+# B ARCHITECTURES AND TRAINING DETAILS
+
+For CIFAR-10, CIFAR-100, and Tiny ImageNet classification experiments, we use a 40-2 Wide Residual Network (Zagoruyko & Komodakis, 2016). The network trains for 100 epochs with a dropout rate of 0.3. The initial learning rate of 0.1 decays following a cosine learning rate schedule (Loshchilov & Hutter, 2017). During fine-tuning of the entire network, we again use a cosine learning rate schedule but with an initial learning rate of 0.001. We use standard flipping and data cropping augmentation, Nesterov momentum, and $\ell _ { 2 }$ weight decay with a coefficient of $\bar { 5 } \times 1 0 ^ { - 4 }$ . SVHN architectures are 16-4 Wide ResNets trained for 20 epochs with an initial learning rate of 0.01 and no data augmentation. For Places365, we use a ResNet-18 pre-trained on Places365. In this Places365 experiment, we tune with Outlier Exposure for 5 epochs, use 512 outlier samples per iteration, and start with a learning rate of 0.0001. Outlier Exposure fine-tuning occurs with each epoch being the length of in-distribution dataset epoch, so that Outlier Exposure completes quickly and does involve reading the entire $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { o E } }$ dataset.
+
+# C TRAINING FROM SCRATCH WITH OUTLIER EXPOSURE USUALLY IMPROVES DETECTION PERFORMANCE
+
+Elsewhere we show results for pre-trained networks that are fine-tuned with OE. However, a network trained from scratch which simultaneously trains with OE tends to give superior results. For example, a CIFAR-10 Wide ResNet trained normally obtains a classification error rate of $5 . 1 6 \%$ and an FPR95 of $3 4 . 9 4 \%$ . Fine-tuned, this network has an error rate of $5 . 2 7 \%$ and an FPR95 of $9 . 5 0 \%$ . Yet if we instead train the network from scratch and expose it to outliers as it trains, then the error rate is $4 . 2 6 \%$ and the FPR95 is $6 . 1 5 \%$ . This architecture corresponds to a $9 . 5 0 \%$ RMS calibration error with OE fine-tuning, but by training with OE from scratch the RMS calibration error is $6 . 1 5 \%$ . Compared to fine-tuning, training a network in tandem with OE tends to produce a network with a better error rate, calibration, and OOD detection performance. The reason why we use OE for fine-tuning is because training from scratch requires more time and sometimes more GPU memory than fine-tuning.
+
+# D OE WORKS ON OTHER VISION ARCHITECTURES
+
+Outlier Exposure also improves vision OOD detection performance for more than just Wide ResNets. Table 9 shows that Outlier Exposure also improves vision OOD detection performance for “All Convolutional Networks” (Salimans & Kingma, 2016).
+
+<table><tr><td rowspan="2">Din</td><td colspan="2">FPR95↓</td><td colspan="2">AUROC ↑</td><td colspan="2">AUPR↑</td></tr><tr><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td><td>MSP</td><td>+OE</td></tr><tr><td>SVHN</td><td>6.84</td><td>0.08</td><td>98.1</td><td>100.0</td><td>90.9</td><td>99.8</td></tr><tr><td>CIFAR-10</td><td>28.4</td><td>14.0</td><td>90.1</td><td>96.7</td><td>58.9</td><td>87.3</td></tr><tr><td>CIFAR-100</td><td>57.5</td><td>43.3</td><td>76.7</td><td>85.3</td><td>33.9</td><td>51.3</td></tr><tr><td>Tiny ImageNet</td><td>75.5</td><td>25.0</td><td>55.4</td><td>82.9</td><td>25.6</td><td>75.3</td></tr></table>
+
+Table 9: Results using an All Convolutional Network architectures. Results are percentages and an average of 10 runs.
+
+# E OUTLIER EXPOSURE WITH $H ( \mathcal { U } ; p )$ SCORES DOES BETTER THAN WITH MSP SCORES
+
+While − maxc $f _ { c } ( x )$ tends to be a discriminative OOD score for example $x$ , models with OE can do better by using $- \dot { H } ( \mathcal { U } ; f ( x ) )$ instead. This alternative accounts for classes with small probability mass rather than just the class with most mass. Additionally, the model with OE is trained to give anomalous examples a uniform posterior not just a lower MSP. This simple change roundly aids performance as shown in Table 10. This general performance improvement is most pronounced on datasets with many classes. For instance, when $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } } =$ Tiny ImageNet and $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } } =$ Gaussian, swapping the MSP score with the $H ( \mathcal { U } ; f ( x ) )$ score increases the AUROC $7 6 . 5 \%$ to $9 7 . 1 \%$ .
+
+<table><tr><td rowspan="2">Din</td><td colspan="2">FPR95↓</td><td colspan="2">AUROC ↑</td><td colspan="2">AUPR ↑</td></tr><tr><td>MSP</td><td>H(U;p)</td><td>MSP</td><td>H(U;p)</td><td>MSP</td><td>H(U;p)</td></tr><tr><td>CIFAR-10</td><td>9.50</td><td>9.04</td><td>97.81</td><td>97.92</td><td>90.48</td><td>90.85</td></tr><tr><td>CIFAR-100</td><td>38.50</td><td>33.31</td><td>87.89</td><td>88.46</td><td>58.15</td><td>58.30</td></tr><tr><td>Tiny ImageNet</td><td>13.99</td><td>7.45</td><td>92.18</td><td>95.45</td><td>79.26</td><td>85.71</td></tr><tr><td>Places365</td><td>28.21</td><td>19.58</td><td>90.57</td><td>92.53</td><td>71.04</td><td>74.39</td></tr></table>
+
+Table 10: Comparison between the maximum softmax probability (MSP) and $H ( \mathcal { U } ; p )$ OOD scoring methods on a network fine-tuned with OE. Results are percentages and an average of 10 runs. For example, CIFAR-10 results are averaged over “Gaussian,” “Rademacher,” . . ., or “CIFAR-100” measurements.
+
+# F EXPANDED LANGUAGE MODELING RESULTS
+
+Detailed OOD detection results with language modeling datasets are shown in Table 11.   
+
+<table><tr><td rowspan="2">Din</td><td rowspan="2">Dest</td><td colspan="2">FPR90↓</td><td colspan="2">AUROC ↑</td><td colspan="2">AUPR↑</td></tr><tr><td>BPC</td><td>+OE</td><td>BPC</td><td>+OE</td><td>BPC</td><td>+OE</td></tr><tr><td rowspan="5">PTB Char</td><td>Answers</td><td>96.9</td><td>49.93</td><td>82.1</td><td>89.6</td><td>81.0</td><td>89.3</td></tr><tr><td>Email</td><td>99.5</td><td>90.64</td><td>80.6</td><td>88.6</td><td>79.4</td><td>89.1</td></tr><tr><td>Newsgroup</td><td>99.8</td><td>99.39</td><td>75.2</td><td>85.0</td><td>73.3</td><td>85.5</td></tr><tr><td>Reviews</td><td>99.0</td><td>74.64</td><td>80.8</td><td>89.0</td><td>79.2</td><td>89.6</td></tr><tr><td>Weblog</td><td>100.0</td><td>100.0</td><td>68.9</td><td>79.2</td><td>67.3</td><td>80.1</td></tr><tr><td colspan="2">Mean</td><td>99.0</td><td>89.4</td><td>77.5</td><td>86.3</td><td>76.0</td><td>86.7</td></tr><tr><td rowspan="5">PTB Word</td><td>Answers</td><td>41.4</td><td>3.65</td><td>81.4</td><td>98.0</td><td>40.5</td><td>94.7</td></tr><tr><td>Email</td><td>64.9</td><td>0.17</td><td>78.1</td><td>99.6</td><td>44.5</td><td>98.9</td></tr><tr><td>Newsgroup</td><td>54.9</td><td>0.17</td><td>77.8</td><td>99.5</td><td>39.8</td><td>98.3</td></tr><tr><td>Reviews</td><td>30.5</td><td>0.85</td><td>88.0</td><td>98.9</td><td>53.6</td><td>96.8</td></tr><tr><td>Weblog</td><td>50.8</td><td>0.08</td><td>80.7</td><td>99.9</td><td>41.5</td><td>99.7</td></tr><tr><td colspan="2">Mean</td><td>48.5</td><td>0.98</td><td>81.2</td><td>99.2</td><td>44.0</td><td>97.8</td></tr></table>
+
+Table 11: OOD detection results on Penn Treebank examples and English Web Treebank outliers. All results are percentages.
+
+The $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets come from the English Web Treebank (Bies et al., 2012), which contains text from five different domains: Yahoo! Answers, emails, newsgroups, product reviews, and weblogs. Other
+
+NLP $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ datasets we consider do not satisfy the language modeling assumption of continuity in the examples, so we do not evaluate on them.
+
+# G CONFIDENCE CALIBRATION
+
+Models integrated into a decision making process should indicate when they are trustworthy, and such models should not have inordinate confidence in their predictions. In an effort to combat a false sense of certainty from overconfident models, we aim to calibrate model confidence. A model is calibrated if its predicted probabilities match empirical frequencies. Thus if a calibrated model predicts an event with $30 \%$ probability, then $30 \%$ of the time the event transpires. Prior research (Guo et al., 2017; Nguyen & O’Connor, 2015; Kuleshov & Liang, 2015) considers calibrating systems where test-time queries are samples from $\mathcal { D } _ { \mathrm { i n } }$ , but systems also encounter samples from Dtest and should also ascribe low confidence to these samples. Hence, we use OE to control the confidence on these samples.
+
+# G.1 METRICS
+
+In order to evaluate a multiclass classifier’s calibration, we present three metrics. First we establish context. For input example $X \in \mathcal { X }$ , let $Y \in \mathcal { Y } \overset {  } { = } \{ 1 , 2 , \ldots , k \}$ be the ground truth class. Let $\widehat { Y }$ be the model’s class prediction, and let $C$ be the corresponding model confidence or prediction probability. Denote the set of prediction-label pairs made by the model with $S = \{ ( \widehat { y } _ { 1 } , \widehat { c } _ { 1 } ) , ( \widehat { y } _ { 2 } , \widehat { c _ { 2 } } ) , \ldots , ( \widehat { y } _ { n } , c _ { n } ) \}$ .
+
+RMS and MAD Calibration Error. The Root Mean Square Calibration Error measures the square root of the expected squared difference between confidence and accuracy at a confidence level. It has the formula $\sqrt { \mathbb { E } _ { C } [ ( \mathbb { P } ( Y = \widehat { Y } | C = c ) - c ) ^ { 2 } ] }$ . A similar formulation which less severely penalizes large confidence-accuracy deviations is the Mean Absolute Value Calibration error, written $\mathbf { \dot { \mathbb { E } } } _ { C } [ | \mathbb { P } ( Y = \mathbf { \overline { { Y } } } | C = c ) - c | ]$ . The MAD Calibration Error is a lower bound of the RMS Calibration Error. To empirically estimate these miscalibration measures, we partition the $n$ samples of $S$ into $b$ bins $\{ B _ { 1 } , \bar { B } _ { 2 } , \dots , \bar { B } _ { b } \}$ with approximately 100 samples in each bin. Unlike Guo et al. (2017), bins are not equally spaced since the distribution of confidence values is not uniform but dynamic. Concretely, the RMS Calibration Error is estimated with the numerically stable formula
+
+$$
+\sqrt { \sum _ { i = 1 } ^ { b } \frac { | B _ { i } | } { n } \biggl ( \frac { 1 } { | B _ { i } | } \sum _ { k \in B _ { i } } \mathbb { 1 } \bigl ( y _ { k } = \widehat { y } _ { k } \bigr ) - \frac { 1 } { | B _ { i } | } \sum _ { k \in B _ { i } } c _ { k } \biggr ) ^ { 2 } } .
+$$
+
+Along similar lines, the MAD Calibration Error—which is an improper scoring rule due to its use of absolute differences rather than squared differences—is estimated with
+
+$$
+\sum _ { i = 1 } ^ { b } \frac { | B _ { i } | } { n } \bigg | \frac { 1 } { | B _ { i } | } \sum _ { k \in B _ { i } } \mathbb { 1 } ( y _ { k } = \widehat { y } _ { k } ) - \frac { 1 } { | B _ { i } | } \sum _ { k \in B _ { i } } c _ { k } \bigg | .
+$$
+
+Soft F1 Score. If a classifier makes only a few mistakes, then most examples should have high confidence. But if the classifier gives all predictions high confidence, including its mistakes, then the previous metrics will indicate that the model is calibrated on the vast majority of instances, despite having systematic miscalibration. The Soft F1 score (Pastor-Pellicer et al., 2013; Hendrycks & Gimpel, 2017) is suited for measuring the calibration of a system where there is an acute imbalance between mistaken and correct decisions. Since we treat mistakes a positive examples, we can write the model’s confidence that the examples are anomalous with $c _ { a } = ( 1 - c _ { 1 } , 1 - c _ { 2 } , \ldots , 1 - c _ { n } )$ . To indicate that an example is positive (mistaken), we use the vector $m \in \{ 0 , 1 \} ^ { n }$ such that $m _ { i } =$ $\mathbb { 1 } ( y _ { i } \neq \widehat { y _ { i } } )$ for $1 \leq i \leq n$ . Then the Soft F1 score is
+
+$$
+{ \frac { c _ { a } ^ { \mathsf { T } } m } { 1 ^ { \mathsf { T } } ( c _ { a } + m ) / 2 } } .
+$$
+
+Table 12: Calibration results for the temperature tuned baseline and temperature tuning $+ \mathrm { O E }$ .   
+
+<table><tr><td rowspan="2">Din</td><td>RMS Calib.</td><td>Error↓</td><td>MAD Calib.</td><td>Error↓</td><td>Soft F1 Score ↑</td></tr><tr><td>Temperature</td><td>+OE</td><td>Temperature</td><td>+OE</td><td>Temperature +OE</td></tr><tr><td>SVHN</td><td>22.3</td><td>4.8</td><td>10.9</td><td>2.4</td><td>52.1 87.9</td></tr><tr><td>CIFAR-10</td><td>19.4</td><td>9.3</td><td>12.6</td><td>5.6</td><td>39.9 69.7</td></tr><tr><td>CIFAR-100</td><td>14.7</td><td>8.2</td><td>11.3</td><td>6.5</td><td>52.8 65.8</td></tr><tr><td>Tiny ImageNet</td><td>12.0</td><td>6.9</td><td>9.0</td><td>4.8</td><td>62.9 72.2</td></tr></table>
+
+# G.2 SETUP AND RESULTS
+
+There are many ways to estimate a classifier’s confidence. One way is to bind a logistic regression branch onto the network, so that confidence values are in $[ 0 , 1 ]$ . Other confidence estimates use the model’s logits $l \in \mathbb { R } ^ { k }$ , such as the estimate $\sigma ( \operatorname* { m a x } _ { i } l _ { i } ) \ \bar { \in } \ [ 0 , 1 ]$ , where $\sigma$ is the logistic sigmoid. Another common confidence estimate is $\begin{array} { r } { \operatorname* { n a x } _ { i } \left[ \exp { ( l _ { i } ) } / \sum _ { j = 1 } ^ { k } \exp { ( l _ { j } ) } \right] } \end{array}$ . A modification of this estimate is our baseline.
+
+Softmax Temperature Tuning. Guo et al. (2017) show that good calibration can be obtained by including a tuned temperature parameter into the softmax: $\begin{array} { r } { \exp ( l _ { i } / T ) / \sum _ { j = 1 } ^ { k } \exp ( l _ { j } / T ) } \end{array}$ . We tune $T$ bto maximize log likelihood on a validation set after the $ \widehat { p } ( y ~ = ~ i ~ | ~ x \rangle ~ =$
+
+Results. In this calibration experiment, the baseline is confidence estimation with softmax temperature tuning. Therefore, we train SVHN, CIFAR-10, CIFAR-100, and Tiny ImageNet classifiers with 5000, 5000, 5000, and 10000 training examples held out, respectively. A copy of this classifier is fine-tuned with Outlier Exposure. Then we determine the optimal temperatures of the original and OE-fine-tuned classifiers on the held-out exampwe take equally many examples from a given in-distribution dataset $\mathcal { D } _ { \mathrm { i n } } ^ { \mathrm { t e s t } }$ To measure calibrand OOD dataset $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ Out-of-distribution points are understood to be incorrectly classified since their label is not in the model’s output space, so calibrated models should assign these out-of-distribution points low confidence. Results are in Table 12. Outlier Exposure noticeably improves model calibration.
+
+# G.3 POSTERIOR RESCALING
+
+While temperature tuning improves calibration, the confidence estimate ${ \widehat { p } } ( y = i \mid x )$ cannot be less than $1 / k$ , $k$ bthe number of classes. For an out-of-distribution example like Gaussian Noise, a good model should have no confidence in its prediction over $k$ classes. One possibility is to add a reject option, or a $( k + 1 ) \mathrm { s t }$ class, which we cover in Section 5. A simpler option we found is to perform an affine transformation of $\widehat { p } ( y = i \mid x ) \in [ 1 / k , 1 ]$ with the formula $( \widehat { p } ( \bar { y } = i \mid x ) - 1 / k ) / ( \bar { 1 } - 1 / k ) \in$ $[ 0 , 1 ]$ b b. This simple transformation makes it possible for a network to express no confidence on an out-of-distribution input and improves calibration performance. As Table 13 shows, this simple 0-1 posterior rescaling technique consistently improves calibration, and the model fine-tuned with OE using temperature tuning and posterior rescaling achieved large calibration improvements.
+
+<table><tr><td></td><td colspan="3">RMS Calib.Error↓</td><td colspan="3">MAD Calib. Error↓</td><td colspan="3">Soft F1 Score ↑</td></tr><tr><td>Din</td><td>Temp</td><td colspan="2">+Rescale+OE</td><td>Temp</td><td colspan="2">+Rescale+OE</td><td>Temp</td><td colspan="2">+Rescale+OE</td></tr><tr><td>SVHN</td><td>22.3</td><td>20.8</td><td>3.0</td><td>10.9</td><td>10.1</td><td>1.0</td><td>52.1</td><td>56.1</td><td>92.7</td></tr><tr><td>CIFAR-10</td><td>19.4</td><td>17.8</td><td>6.7</td><td>12.6</td><td>11.7</td><td>4.1</td><td>39.9</td><td>42.8</td><td>73.9</td></tr><tr><td>CIFAR-100</td><td>14.7</td><td>14.4</td><td>8.1</td><td>11.3</td><td>11.1</td><td>6.4</td><td>52.8</td><td>53.1</td><td>66.1</td></tr><tr><td>Tiny ImageNet</td><td>12.0</td><td>11.9</td><td>6.9</td><td>9.0</td><td>8.8</td><td>4.8</td><td>62.9</td><td>63.1</td><td>72.3</td></tr></table>
+
+Table 13: Calibration results for the softmax temperature tuning baseline, the same baseline after adding Posterior Rescaling, and temperature tuning $^ +$ Posterior Rescaling $+ \mathrm { O E }$ .
+
+![](images/c0d87cbc8f88599c3c8368e71b80eefdf98d356c5d7af4c5424064d60846f687.jpg)  
+Figure 4: ROC curves with Tiny ImageNet as $\mathcal { D } _ { \mathrm { i n } }$ and Textures, Places365, LSUN, and ImageNet as $\mathcal { D } _ { \mathrm { o u t } } ^ { \mathrm { t e s t } }$ . Figures show the curves corresponding to the maximum softmax probability (MSP) baseline detector and the MSP detector with Outlier Exposure (OE).
+
+In Figure 4, we show additional PR and ROC Curves using the Tiny ImageNet dataset and various anomalous distributions.

parse/train/rkFBJv9gg/rkFBJv9gg.md

@@ -0,0 +1,258 @@
+# LEARNING FEATURES OF MUSIC FROM SCRATCH
+
+John Thickstun1, Zaid Harchaoui2 & Sham M. Kakade1,2   
+1 Department of Computer Science and Engineering, 2 Department of Statistics   
+University of Washington   
+Seattle, WA 98195, USA   
+{thickstn,sham}@cs.washington.edu, name@uw.edu
+
+# ABSTRACT
+
+This paper introduces a new large-scale music dataset, MusicNet, to serve as a source of supervision and evaluation of machine learning methods for music research. MusicNet consists of hundreds of freely-licensed classical music recordings by 10 composers, written for 11 instruments, together with instrument/note annotations resulting in over 1 million temporal labels on 34 hours of chamber music performances under various studio and microphone conditions.
+
+The paper defines a multi-label classification task to predict notes in musical recordings, along with an evaluation protocol, and benchmarks several machine learning architectures for this task: i) learning from spectrogram features; ii) endto-end learning with a neural net; iii) end-to-end learning with a convolutional neural net. These experiments show that end-to-end models trained for note prediction learn frequency selective filters as a low-level representation of audio.
+
+# 1 INTRODUCTION
+
+Music research has benefited recently from the effectiveness of machine learning methods on a wide range of problems from music recommendation (van den Oord et al., 2013; McFee & Lanckriet, 2011) to music generation (Hadjeres & Pachet, 2016); see also the recent demos of the Google Magenta project1. As of today, there is no large publicly available labeled dataset for the simple yet challenging task of note prediction for classical music. The MIREX MultiF0 Development Set (Benetos & Dixon, 2011) and the Bach10 dataset (Duan et al., 2011) together contain less than 7 minutes of labeled music. These datasets were designed for method evaluation, not for training supervised learning methods.
+
+This situation stands in contrast to other application domains of machine learning. For instance, in computer vision large labeled datasets such as ImageNet (Russakovsky et al., 2015) are fruitfully used to train end-to-end learning architectures. Learned feature representations have outperformed traditional hand-crafted low-level visual features and lead to tremendous progress for image classification. In (Humphrey et al., 2012), Humphrey, Bello, and LeCun issued a call to action: “Deep architectures often require a large amount of labeled data for supervised training, a luxury music informatics has never really enjoyed. Given the proven success of supervised methods, MIR would likely benefit a good deal from a concentrated effort in the curation of sharable data in a sustainable manner.”
+
+This paper introduces a new large labeled dataset, MusicNet, which is publicly available2 as a resource for learning feature representations of music. MusicNet is a corpus of aligned labels on freely-licensed classical music recordings, made possible by licensing initiatives of the European Archive, the Isabella Stewart Gardner Museum, Musopen, and various individual artists. The dataset consists of 34 hours of human-verified aligned recordings, containing a total of 1, 299, 329 individual labels on segments of these recordings. Table 1 summarizes statistics of MusicNet.
+
+The focus of this paper’s experiments is to learn low-level features of music from raw audio data. In Sect. 4, we will construct a multi-label classification task to predict notes in musical recordings, along with an evaluation protocol. We will consider a variety of machine learning architectures for this task: i) learning from spectrogram features; ii) end-to-end learning with a neural net; iii) endto-end learning with a convolutional neural net. Each of the proposed end-to-end models learns a set of frequency selective filters as low-level features of musical audio, which are similar in spirit to a spectrogram. The learned low-level features are visualized in Figure 1. The learned features modestly outperform spectrogram features; we will explore possible reasons for this in Sect. 5.
+
+MusicNet   
+Table 1: Summary statistics of the MusicNet dataset. See Sect. 2 for further discussion of MusicNet and Sect. 3 for a description of the labelling process. Appendix A discusses the methodology for computing error rate of this process.   
+
+<table><tr><td> Minutes</td><td>Labels</td><td>Recordings</td><td>Error Rate</td><td></td><td>Composer</td><td> Minutes</td><td>Labels</td></tr><tr><td>2,048</td><td>1,299,329</td><td>330</td><td colspan="2">4.0%</td><td>Beethoven Schubert</td><td>1,085 253</td><td>736,072</td></tr><tr><td colspan="6">Labels</td><td>192</td><td>133,109</td><td>146,648</td></tr><tr><td colspan="6">Ensemble Minutes Solo Piano 917</td><td>Brahms Mozart Bach</td><td>156</td><td>99,641</td></tr><tr><td colspan="6"> String Quartet</td><td>Dvorak</td><td>184</td><td>62,782</td></tr><tr><td colspan="6"> Accompanied Violin</td><td></td><td>56</td><td>46,261</td></tr><tr><td colspan="6"> Piano Quartet</td><td>Cambini</td><td>43</td><td>24,820</td></tr><tr><td colspan="6"> Accompanied Cello</td><td>Faure</td><td></td><td>22,349</td></tr><tr><td colspan="6"> String Sextet</td><td>Ravel</td><td>27</td><td>21,243</td></tr><tr><td colspan="6">Piano Trio</td><td>Haydn</td><td></td><td>6,404</td></tr><tr><td colspan="6">Piano Quintet</td><td></td><td></td><td></td></tr><tr><td colspan="6">25 Wind Quintet 43</td><td> Instrument</td><td> Minutes</td><td>Labels</td></tr><tr><td colspan="6">Horn Piano Trio 30</td><td>Piano</td><td>1346</td><td>794,532</td></tr><tr><td colspan="6">Wind Octet 23</td><td>Violin</td><td>874</td><td>230,484</td></tr><tr><td colspan="6">Clarinet-Cello-Piano Trio</td><td>Viola</td><td>621</td><td>99,407</td></tr><tr><td colspan="6">2524 Pairs Clarinet-Horn-Bassoon</td><td>Cello</td><td>800</td><td>99,132</td></tr><tr><td colspan="6">Clarinet Quintet 26</td><td>Clarinet</td><td>173</td><td>24,426</td></tr><tr><td colspan="6">Solo Cello 49</td><td>Bassoon</td><td>102</td><td>14,954</td></tr><tr><td colspan="6">Accompanied Clarinet 20</td><td>Horn</td><td>132</td><td>11,468</td></tr><tr><td colspan="6">10,049 Solo Violin 30</td><td>Oboe</td><td>66</td><td></td></tr><tr><td colspan="6">Violin and Harpsichord 16</td><td>Flute</td><td>69</td><td>8,696</td></tr><tr><td colspan="6">Viola Quintet 15</td><td></td><td></td><td>8,310</td></tr><tr><td colspan="6"> Solo Flute</td><td>Harpsichord</td><td>16</td><td>4,914</td></tr><tr><td colspan="6"></td><td> String Bass</td><td>38</td><td>3,006</td></tr><tr><td>Piano</td><td>Violin</td><td>Cello</td><td>Viola</td><td>Clarinet Bassoon</td><td>Horn</td><td>Oboe</td><td></td><td></td><td></td></tr><tr><td colspan="6"></td><td></td><td>Flute</td><td>Bass Harpsichord</td><td></td></tr><tr><td>Notes</td><td>83</td><td>51</td><td>51 51</td><td>41</td><td>36</td><td>41 28</td><td>37</td><td>43</td><td>51</td></tr></table>
+
+![](images/11de063179b53a961d7c5abb73ccbb146c9b2303b58b47a462d7f6fd90a294d7.jpg)  
+Figure 1: (Left) Bottom-level weights learned by a two-layer ReLU network trained on 16,384- samples windows $( \approx 1 / 3$ seconds) of raw audio with $\ell _ { 2 }$ regularized $\lambda = 1$ ) square loss for multilabel note classification on raw audio recordings. (Middle) Magnified view of the center of each set of weights. (Right) The truncated frequency spectrum of each set of weights.
+
+# 2 MUSICNET
+
+Related Works. The experiments in this paper suggest that large amounts of data are necessary to recovering useful features from music; see Sect. 4.5 for details. The Lakh dataset, released this summer based on the work of Raffel & Ellis (2015), offers note-level annotations for many 30- second clips of pop music in the Million Song Dataset (McFee et al., 2012). The syncRWC dataset is a subset of the RWC dataset (Goto et al., 2003) consisting of 61 recordings aligned to scores using the protocol described in Ewert et al. (2009). The MAPS dataset (Emiya et al., 2010) is a mixture of acoustic and synthesized data, which expressive models could overfit. The Mazurka project3 consists of commercial music. Access to the RWC and Mazurka datasets comes at both a cost and inconvenience. Both the MAPS and Mazurka datasets are comprised entirely of piano music.
+
+The MusicNet Dataset. MusicNet is a public collection of labels (exemplified in Table 2) for 330 freely-licensed classical music recordings of a variety of instruments arranged in small chamber ensembles under various studio and microphone conditions. The recordings average 6 minutes in length. The shortest recording in the dataset is 55 seconds and the longest is almost 18 minutes. Table 1 summarizes the statistics of MusicNet with breakdowns into various types of labels. Table 2 demonstrates examples of labels from the MusicNet dataset.
+
+<table><tr><td>Start</td><td>End</td><td>Instrument</td><td>Note</td><td>Measure</td><td>Beat</td><td>Note Value</td></tr><tr><td>45.29</td><td>45.49</td><td>Violin</td><td>G5</td><td>21</td><td>3</td><td>Eighth</td></tr><tr><td>48.99</td><td>50.13</td><td>Cello</td><td>A#3</td><td>24</td><td>2</td><td>Dotted Half</td></tr><tr><td>82.91</td><td>83.12</td><td>Viola</td><td>C5</td><td>51</td><td>2.5</td><td>Eighth</td></tr></table>
+
+Table 2: MusicNet labels on the Pascal String Quartet’s recording of Beethoven’s Opus 127, String Quartet No. 12 in E-flat major, I - Maestoso - Allegro. Creative commons use of this recording is made possible by the work of the European Archive.
+
+MusicNet labels come from 513 label classes using the most naive definition of a class: distinct instrument/note combinations. The breakdowns reported in Table 1 indicate the number of distinct notes that appear for each instrument in our dataset. For example, while a piano has 88 keys only 83 of them are performed in MusicNet. For many tasks a note’s value will be a part of its label, in which case the number of classes will expand by approximately an order of magnitude after taking the cartesian product of the set of classes with the set of values: quarter-note, eighth-note, triplet, etc. Labels regularly overlap in the time series, creating polyphonic multi-labels.
+
+MusicNet is skewed towards Beethoven, thanks to the composer’s popularity among performing ensembles. The dataset is also skewed towards Solo Piano due to an abundance of digital scores available for piano works. For training purposes, researchers may want to augment this dataset to increase coverage of instruments such as Flute and Oboe that are under-represented in MusicNet. Commercial recordings could be used for this purpose and labeled using the alignment protocol described in Sect. 3.
+
+# 3 DATASET CONSTRUCTION
+
+MusicNet recordings are freely-licensed classical music collected from the European Archive, the Isabella Stewart Gardner Museum, Musopen, and various artists’ collections. The MusicNet labels are retrieved from digital MIDI scores, collected from various archives including the Classical Archives (classicalarchives.com) Suzuchan’s Classic MIDI (suzumidi.com) and HarfeSoft (harfesoft.de). The methods in this section produce an alignment between a digital score and a corresponding freely-licensed recording. A recording is labeled with events in the score, associated to times in the performance via the alignment. Scores containing 6, 550, 760 additional labels are available on request to researchers who wish to augment MusicNet with commercial recordings.
+
+Music-to-score alignment is a long-standing problem in the music research and signal processing communities (Raphael, 1999). Dynamic time warping (DTW) is a classical approach to this problem. An early use of DTW for music alignment is Orio & Schwarz (2001) where a recording is aligned to a crude synthesis of its score, designed to capture some of the structure of an overtone series. The method described in this paper aligns recordings to synthesized performances of scores, using side information from a commercial synthesizer. To the best of our knowledge, commercial synthesis was first used for the purpose of alignment in Turetsky & Ellis (2003).
+
+The majority of previous work on alignment focuses on pop music. This is more challenging than aligning classical music because commercial synthesizers do a poor job reproducing the wide variety of vocal and instrumental timbers that appear in modern pop. Furthermore, pop features inharmonic instruments such as drums for which natural metrics on frequency representations–including $\ell ^ { 2 }$ –are not meaningful. For classical music to score alignment, a variant of the techniques described in Turetsky & Ellis (2003) works robustly. This method is described below; we discuss the evaluation of this procedure and its error rate on MusicNet in the appendix.
+
+![](images/5b140393006a315d552c21453c6ab01f5f4265167475eee6b5afb8c1c125a9a5.jpg)  
+Figure 2: (Left) Heatmap visualization of local alignment costs between the synthesized and recorded spectrograms, with the optimal alignment path in red. The block from $x = 0$ to $x = 1 0 0$ frames corresponds to silence at the beginning of the recorded performance. The slope of the alignment can be interpreted as an instantaneous tempo ratio between the recorded and synthesized performances. The curvature in the alignment between $x \ = \ 1 0 0$ and $x \ = \ 1 7 5$ corresponds to an extension of the first notes by the performer. (Right) Annotation of note onsets on the spectrogram of the recorded performance, determined by the alignment shown on the left.
+
+In order to align the performance with a score, we need to define a metric that compares short segments of the score with segments of a performance. Musical scores can be expressed as binary vectors in $E \times K$ where $E = \{ 1 , \ldots , n \}$ and $K$ is a dictionary of notes. Performances reside in $\mathbb { R } ^ { T \times p }$ , where $T \in \{ 1 , \dots , m \}$ is a sequence of time steps and $p$ is the dimensionality of the spectrogram at time $T$ . Given some local cost function $C : ( \mathbb { R } ^ { p } , K ) \to \mathbb { R }$ , a score $\mathbf { Y } \in E \times K$ , and a performance $\mathbf { X } \in \mathbb { R } ^ { T \times p }$ , the alignment problem is to
+
+$$
+\begin{array} { r l r } & { \underset { t \in \mathbb { Z } ^ { n } } { \mathrm { m i n i m i z e } } } & { \displaystyle \sum _ { i = 1 } ^ { n } C ( \mathbf { X } _ { t _ { i } } , \mathbf { Y } _ { i } ) } \\ & { \mathrm { s u b j e c t ~ t o } } & { t _ { 0 } = 0 , } \\ & { t _ { n } = m , } \\ & { t _ { i } \leq t _ { j } } & { \mathrm { i f } i < j . } \end{array}
+$$
+
+Dynamic time warping gives an exact solution to the problem in $\mathcal { O } ( m n )$ time and space.
+
+The success of dynamic time warping depends on the metric used to compare the score and the performance. Previous works can be broadly categorized into three groups that define an alignment cost $C$ between segments of music $\mathbf { X }$ and score $\mathbf { y }$ by injecting them into a common normed space via maps $\Psi$ and $\Phi$ :
+
+$$
+C ( \mathbf { x } , \mathbf { y } ) = \| \Psi ( \mathbf { x } ) - \Phi ( \mathbf { y } ) \|
+$$
+
+The most popular approach–and the one adopted by this paper–maps the score into the space of the performance (Orio & Schwarz, 2001; Turetsky $\&$ Ellis, 2003; Soulez et al., 2003). An alternative approach maps both the score and performance into some third space, commonly a chromogram space (Hu et al., 2003; Izmirli $\&$ Dannenberg, 2010; Joder et al., 2013). Finally, some recent methods consider alignment in score space, taking $\Phi = \mathrm { I d }$ and learning $\Psi$ (Garreau et al., 2014; Lajugie et al., 2016).
+
+With reference to the general cost (2), we must specify the maps $\Psi , \Phi$ , and the norm $\| \cdot \|$ . We compute the cost in the performance feature space $\mathbb { R } ^ { p }$ , hence we take $\Psi = \mathrm { I d }$ . For the features, we use the log-spectrogram with a window size of 2048 samples. We use a stride of 512 samples between features. Hence adjacent feature frames are computed with $7 5 \%$ overlap. For audio sampled at $4 4 . 1 \mathrm { k H z }$ , this results in a feature representation with 4 $\mathrm { \Delta } 4 , 1 0 0 / 5 1 2 \approx 8 6 $ frames per second. A discussion of these parameter choices can be found in the appendix. The map $\Phi$ is computed by a synthetizer: we used Plogue’s Sforzando sampler together with Garritan’s Personal Orchestra 4 sample library.
+
+For a (pseudo)-metric on $\mathbb { R } ^ { p }$ , we take the $\ell ^ { 2 }$ norm $\| \cdot \| _ { 2 }$ on the low 50 dimensions of $\mathbb { R } ^ { p }$ . Recall that $\mathbb { R } ^ { p }$ represents Fourier components, so we can roughly interpret the $k$ ’th coordinate of $\mathbb { R } ^ { p }$ as the energy associated with the frequency $k \times ( 2 2 , 0 5 0 / \mathrm { 1 0 2 4 } ) \approx \bar { k } \times 2 2 . 5 \mathrm { H z }$ , where $2 2 , 0 5 0 \mathrm { H z }$ is the Nyquist frequency of a signal sampled at $4 4 . 1 \mathrm { k H z }$ . The 50 dimension cutoff is chosen empirically: we observe that the resulting alignments are more accurate using a small number of low-frequency bins rather than the full space $\mathbb { R } ^ { p }$ . Synthesizers do not accurately reproduce the high-frequency features of a musical instrument; by ignoring the high frequencies, we align on a part of the spectrum where the synthesis is most accurate. The proposed choice of cutoff is aggressive compared to usual settings; for instance, Turetsky & Ellis (2003) propose cutoffs in the $2 . 5 \mathrm { k H z }$ range. The fundamental frequencies of many notes in MusicNet are higher than the $5 0 \times 2 2 . 5 \mathrm { H z } \approx 1 \mathrm { k H z }$ cutoff. Nevertheless, we find that all notes align well using only the low-frequency information.
+
+# 4 METHODS
+
+We consider identification of notes in a segment of audio $\textbf { x } \in \ \mathcal { X }$ as a multi-label classification problem, modeled as follows. Assign each audio segment a binary label vector $\mathbf { y } \in \{ 0 , 1 \} ^ { 1 2 8 }$ . The 128 dimensions correspond to frequency codes for notes, and ${ \bf y } _ { n } = 1$ if note $n$ is present at the midpoint of $\mathbf { x }$ . Let $f : \mathcal { X } \to \mathcal { H }$ indicate a feature map. We train a multivariate linear regression to predict $\hat { \mathbf { y } }$ given $f ( \mathbf { x } )$ , which we optimize for square loss. The vector $\hat { \mathbf { y } }$ can be interpreted as a multi-label estimate of notes in $\mathbf { x }$ by choosing a threshold $c$ and predicting label $n$ iff ${ \hat { \mathbf { y } } } _ { n } > c$ . We search for the value $c$ that maximizes $F _ { 1 }$ -score on a sampled subset of MusicNet.
+
+# 4.1 RELATED WORK
+
+Learning on raw audio is studied in both the music and speech communities. Supervised learning on music has been driven by access to labeled datasets. Pop music labeled with chords (Harte, 2010) has lead to a long line of work on chord recognition, most recently Korzeniowsk & Widmer (2016). Genre labels and other metadata has also attracted work on representation learning, for example Dieleman & Schrauwen (2014). There is also substantial work modeling raw audio representations of speech; a current example is Tokuda & Zen (2016). Recent work from Google DeepMind explores generative models of raw audio, applied to both speech and music (van den Oord et al., 2016).
+
+The music community has worked extensively on a closely related problem to note prediction: fundamental frequency estimation. This is the analysis of fundamental (in contrast to overtone) frequencies in short audio segments; these frequencies are typically considered as proxies for notes. Because access to large labeled datasets was historically limited, most of these works are unsupervised. A good overview of this literature can be found in Benetos et al. (2013). Variants of non-negative matrix factorization are popular for this task; a recent example is Khlif & Sethu (2015). A different line of work models audio probabilistically, for example Berg-Kirkpatrick et al. (2014). Recent work by Kelz et al. (2016) explores supervised models, trained using the MAPS piano dataset.
+
+# 4.2 MULTI-LAYER PERCEPTRONS
+
+We build a two-layer network with features $f _ { i } ( \mathbf { x } ) = \log \left( 1 + \operatorname* { m a x } ( 0 , \mathbf { w } _ { i } ^ { T } \mathbf { x } ) \right)$ . We find that compression introduced by a logarithm improves performance versus a standard ReLU network (see Table 3). Figure 1 illustrates a selection of weights $w _ { i }$ learned by the bottom layer of this network. The weights learned by the network are modulated sinusoids. This explains the effectiveness of spectrograms as a low-level representation of musical audio. The weights decay at the boundaries, analogous to Gabor filters in vision. This behavior is explained by the labeling methodology: the audio segments used here are approximately $1 / 3$ of a second long, and a segment is given a note label if that note is on in the center of the segment. Therefore information at the boundaries of the segment is less useful for prediction than information nearer to the center.
+
+# 4.3 (LOG-)SPECTROGRAMS
+
+Spectrograms are an engineered feature representation for musical audio signals, available in popular software packages such as librosa (McFee et al., 2015). Spectrograms (resp. log-spectrograms) are closely related to a two-layer ReLU network (resp. the log-ReLU network described above). If $\mathbf { x } = ( x _ { 1 } , \dots , x _ { t } )$ denotes a segment of an audio signal of length $t$ then we can define
+
+$$
+\mathrm { S p e c } _ { k } ( \mathbf { x } ) \equiv \left| \sum _ { s = 0 } ^ { t - 1 } e ^ { - 2 \pi i k s / t } x _ { s } \right| ^ { 2 } = \left( \sum _ { s = 0 } ^ { t - 1 } \cos ( 2 \pi k s / t ) x _ { s } \right) ^ { 2 } + \left( \sum _ { s = 0 } ^ { t - 1 } \sin ( 2 \pi k s / t ) x _ { s } \right) ^ { 2 } .
+$$
+
+These features are not precisely learnable by a two-layer ReLU network. But recall that $| x | =$ $\operatorname* { m a x } ( 0 , x ) + \operatorname* { m a x } ( 0 , - \bar { x } )$ and if we take weight vectors ${ \bf u } , { \bf v } \in \mathbb { R } ^ { T }$ with $u _ { s } = \cos ( 2 \pi k s / t )$ and $v _ { s } = \sin ( 2 \pi k s / t )$ then the ReLU network can learn
+
+$$
+f _ { k , \mathrm { c o s } } ( \mathbf { x } ) + f _ { k , \mathrm { s i n } } ( \mathbf { x } ) \equiv | \mathbf { u } ^ { T } \mathbf { x } | + | \mathbf { v } ^ { T } \mathbf { x } | = \left| \sum _ { s = 0 } ^ { t - 1 } \mathrm { c o s } ( 2 \pi k s / t ) x _ { s } \right| + \left| \sum _ { s = 0 } ^ { t - 1 } \mathrm { s i n } ( 2 \pi k s / t ) x _ { s } \right| .
+$$
+
+We call this family of features a ReLUgram and observe that it has a similar form to the spectrogram; we merely replace the $x \mapsto x ^ { 2 }$ non-linearity of the spectrogram with $x \mapsto | x |$ . These features achieve similar performance to spectrograms on the classification task (see Table 3).
+
+# 4.4 WINDOW SIZE
+
+When we parameterize a network, we must choose the width of the set of weights in the bottom layer. This width is called the receptive field in the vision community; in the music community it is called the window size. Traditional frequency analyses, including spectrograms, are highly sensitive to the window size. Windows must be long enough to capture relevant information, but not so long that they lose temporal resolution; this is the classical time-frequency tradeoff. Furthermore, windowed frequency analysis is subject to boundary effects, known as spectral leakage. Classical signal processing attempts to dampen these effects with predefined window functions, which apply a mask that attenuates the signal at the boundaries (Rabiner & Schafer, 2007).
+
+The proposed end-to-end models learn window functions. If we parameterize these models with a large window size then the model will learn that distant information is irrelevant to local prediction, so the magnitude of the learned weights will attenuate at the boundaries. We therefore focus on two window sizes: 2048 samples, which captures the local content of the signal, and 16,384 samples, which is sufficient to capture almost all relevant context (again see Figure 1).
+
+# 4.5 REGULARIZATION
+
+The size of MusicNet is essential to achieving the results in Figure 1. In Figure 3 (Left) we optimize a two-layer ReLU network on a small subset of MusicNet consisting of 65, 000 monophonic data points. While these features do exhibit dominant frequencies, the signal is quite noisy. Comparable noisy frequency selective features were recovered by Dieleman & Schrauwen (2014); see their Figure 3. We can recover clean features on a small dataset using heavy regularization, but this destroys classification performance; regularizing with dropout poses a similar tradeoff. By contrast, Figure 3 (Right) shows weights learned by an unregularized two-layer network trained on the full MusicNet dataset. The models described in this paper do not overfit to MusicNet and optimal performance (reported in Table 3) is achieved without regularization.
+
+# 4.6 CONVOLUTIONAL NETWORKS
+
+Previously, we estimated $\hat { \mathbf { y } }$ by regressing against $f ( \mathbf { x } )$ . We now consider a convolutional model that regresses against features of a collection of shifted segments $\mathbf { x } _ { \ell }$ near to the original segment x. The learned features of this network are visually comparable to those learned by the fully connected network (Figure 1). The parameters of this network are the receptive field, stride, and pooling regions.
+
+![](images/3c0669fca76136809bc2d927779736f34a74a909811dd646afdbc2c66b15c673.jpg)  
+Figure 3: (Left) Features learned by a 2-layer ReLU network trained on small monophonic subset of MusicNet. (Right) Features learned by the same network, trained on the full MusicNet dataset.
+
+The results reported in Table 3 are achieved with 500 hidden units using a receptive field of 2, 048 samples with an 8-sample stride across a window of 16, 384 samples. These features are grouped into average pools of width 16, with a stride of 8 features between pools. A max-pooling operation yields similar results. The learned features are consistent across different parameterizations. In all cases the learned features are comparable to those of a fully connected network.
+
+# 5 RESULTS
+
+We hold out a test set of 3 recordings for all the results reported in this section:
+
+• Bach’s Prelude in D major for Solo Piano. WTK Book 1, No 5. Performed by Kimiko Ishizaka. MusicNet recording id 2303.   
+• Mozart’s Serenade in E-flat major. K375, Movement 4 - Menuetto. Performed by the Soni Ventorum Wind Quintet. MusicNet recording id 1819.   
+• Beethoven’s String Quartet No. 13 in B-flat major. Opus 130, Movement 2 - Presto. Released by the European Archive. MusicNet recording id 2382.
+
+The test set is a representative sampling of MusicNet: it covers most of the instruments in the dataset in small, medium, and large ensembles. The test data points are evenly spaced segments separated by 512 samples, between the 1st and 91st seconds of each recording. For the wider features, there is substantial overlap between adjacent segments. Each segment is labeled with the notes that are on in the middle of the segment.
+
+![](images/11641190697d2c62117bfa33adfae72bd0e1b39586d981eba8920ed2506e51c4.jpg)  
+Figure 4: Precision-recall curves for the convolutional network on the test set. Curves are evaluated on subsets of the test set consisting of all data points (blue); points with exactly one label (monophonic; green); and points with exactly three labels (red).
+
+We evaluate our models on three scores: precision, recall, and average precision. The precision score is the count of correct predictions by the model (across all data points) divided by the total number of predictions by the model. The recall score is the count of correct predictions by the model divided by the total number of (ground truth) labels in the test set. Precision and recall are parameterized by the note prediction threshold $c$ (see Sect. 4). By varying $c$ , we construct precision-recall curves (see Figure 4). The average precision score is the area under the precision-recall curve.
+
+<table><tr><td>Representation</td><td>Window Size</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>log-spectrograms</td><td>1,024</td><td>49.0%</td><td>40.5%</td><td>39.8%</td></tr><tr><td>spectrograms</td><td>2,048</td><td>28.9%</td><td>52.5 %</td><td>32.9%</td></tr><tr><td>log-spectrograms</td><td>2,048</td><td>61.9%</td><td>42.0%</td><td>48.8%</td></tr><tr><td>log-ReLUgrams</td><td>2.048</td><td>58.9%</td><td>47.9%</td><td>49.3%</td></tr><tr><td>MLP,500 nodes</td><td>2.048</td><td>50.1%</td><td>58.0%</td><td>52.1%</td></tr><tr><td>MLP, 2500 nodes</td><td>2.048</td><td>53.6%</td><td>62.3%</td><td>56.2%</td></tr><tr><td>AvgPool,2 stride</td><td>2,148</td><td>53.4%</td><td>62.5%</td><td>56.4%</td></tr><tr><td>log-spectrograms</td><td>8,192</td><td>64.2%</td><td>28.6%</td><td>52.1%</td></tr><tr><td>log-spectrograms</td><td>16,384</td><td>58.4%</td><td>18.1%</td><td>45.5%</td></tr><tr><td>MLP, 500 nodes</td><td>16,384</td><td>54.4%</td><td>64.8%</td><td>60.0%</td></tr><tr><td>CNN, 64 stride</td><td>16,384</td><td>60.5%</td><td>71.9%</td><td>67.8%</td></tr></table>
+
+Table 3: Benchmark results on MusicNet for models discussed in this paper. The learned representations are optimized for square loss with SGD using the Tensorflow library (Abadi et al.). We report the precision and recall corresponding to the best $F _ { 1 }$ -score on validation data.
+
+A spectrogram of length $n$ is computed from $2 n$ samples, so the linear 1024-point spectrogram model is directly comparable to the MLP runs with 2048 raw samples. Learned features4 modestly outperform spectrograms for comparable window sizes. The discussion of windowing in Sect. 4.4 partially explains this. Figure 5 suggests a second reason. Recall (Sect. 4.3) that the spectrogram features can be interpreted as the magnitude of the signal’s inner product with sine waves of linearly spaced frequencies. In contrast, the proposed networks learn weights with frequencies distributed similarly to the distribution of notes in MusicNet (Figure 5). This gives the network higher resolution in the most critical frequency regions.
+
+![](images/515e332fb787091151cc1fe1f015f9b0c0daa6c8d967fc5e24577abcd6ab5653.jpg)  
+Figure 5: (Left) The frequency distribution of notes in MusicNet. (Right) The frequency distribution of learned nodes in a 500-node, two-layer ReLU network.
+
+# ACKNOWLEDGMENTS
+
+We thank Bob L. Sturm for his detailed feedback on an earlier version of the paper. We also thank Brian McFee and Colin Raffel for fruitful discussions. Sham Kakade acknowledges funding from the Washington Research Foundation for innovation in Data-intensive Discovery. Zaid Harchaoui acknowledges funding from the program ”Learning in Machines and Brains” of CIFAR.
+
+REFERENCES   
+M. Abadi, A. Agarwal, P. Barham, E. Brevdo, Z. Chen, C. Citro, G. Corrado, A. Davis, J. Dean, M. Devin, S. Ghemawat, I. Goodfellow, A. Harp, G. Irving, M. Isard, Y. Jia, R. Jozefowicz, L. Kaiser, M. Kudlur, J. Levenberg, D. Mane, R. Monga, S. Moore, D. Murray, C. Olah, M. Schuster, J. Shlens, B. Steiner, I. Sutskever, K. Talwar, P. Tucker, V. Vanhoucke, V. Vasudevan, F. Viegas, O. Vinyals, P. Warden, M. Wattenberg, M. Wicke, Y. Yu, and X. Zheng. TensorFlow: Largescale machine learning on heterogeneous systems. URL http://tensorflow.org/.   
+E. Benetos and S. Dixon. Joint multi-pitch detection using harmonic envelope estimation for polyphonic music transcription. IEEE Selected Topics in Signal Processing, 2011.   
+E. Benetos, S. Dixon, D. Giannoulis, H. Kirchoff, and A. Klapuri. Automatic music transcription: challenges and future directions. Journal of Intelligent Information Systems, 2013.   
+T. Berg-Kirkpatrick, J. Andreas, and D. Klein. Unsupervised transcription of piano music. NIPS, 2014.   
+S. Dieleman and B. Schrauwen. End-to-end learning for music audio. ICASSP, 2014.   
+Z. Duan, B. Pardo, and C. Zhang. Multiple fundamental frequency estimation by modeling spectral peaks and non-peak regions. TASLP, 2011.   
+V. Emiya, R. Badeau, and B. David. Multipitch estimation of piano sounds using a new probabilistic spectral smoothness principle. TASLP, 2010.   
+S. Ewert, M. Muller, and P. Grosche. High resolution audio synchronization using chroma features. ¨ ICASSP, 2009.   
+D. Garreau, R. Lajugie, S. Arlot, and F. Bach. Metric learning for temporal sequence alignment. NIPS, 2014.   
+M. Goto, H. Hashiguchi, T. Nishimura, and R. Oka. RWC music database: Music genre database and musical instrument sound database. ISMIR, 2003.   
+Gaetan Hadjeres and Franc¸ois Pachet. Deepbach: a steerable model for bach chorales generation. ¨ arXiv preprint, 2016.   
+C. Harte. Towards Automatic Extraction of Harmony Information from Music Signals. PhD thesis, Department of Electrical Engineering, Queen Mary, University of London, 2010.   
+N. Hu, R. B. Dannenberg, and G. Tzanetakis. Polyphonic audio matching and alignment for music retrieval. IEEE Workshop on Applications of Signal Processing to Audio and Acoustics, 2003.   
+E. J. Humphrey, J. P. Bello, and Y. LeCun. Moving beyond feature design: Deep architectures and automatic feature learning in music informatics. ISMIR, 2012.   
+O. Izmirli and R. B. Dannenberg. Understanding features and distance functions for music sequence alignment. ISMIR, 2010.   
+C. Joder, S. Essid, and G. Richard. Learning optimal features for polyphonic audio-to-score alignment. TASLP, 2013.   
+R. Kelz, M. Dorfer, F. Korzeniowski, S. Bock, A. Arzt, and G. Widmer. On the potential of simple ¨ framewise approaches to piano transcription. ISMIR, 2016.   
+A. Khlif and V. Sethu. An iterative multi range non-negative matrix factorization algorithm for polyphonic music transcription. ISMIR, 2015.   
+F. Korzeniowsk and G. Widmer. Feature learning for chord recognition: the deep chroma extractor. ISMIR, 2016.   
+R. Lajugie, P. Bojanowski, P. Cuvillier, S. Arlot, and F. Bach. A weakly-supervised discriminative model for audio-to-score alignment. ICASSP, 2016.   
+B. McFee and G. Lanckriet. Learning multi-modal similarity. JMLR, 2011.   
+B. McFee, T. Bertin-Mahieux, D. P. W. Ellis, and G. Lanckriet. The million song dataset challenge. Proceedings of the 21st International Conference on World Wide Web, 2012.   
+B. McFee, C. Raffel, D. Liang, D. P. W. Ellis, M. McVicar, E. Battenberg, and O. Nieto. librosa: Audio and music signal analysis in python. SCIPY, 2015.   
+N. Orio and D. Schwarz. Alignment of monophonic and polyphonic music to a score. International Computer Music Conference, 2001.   
+G. Poliner and D. P. W. Ellis. A discriminative model for polyphonic piano transcription. EURASIP Journal on Applied Signal Processing, 2007.   
+L. Rabiner and R. Schafer. Introduction to digital speech processing. Foundations and trends in signal processing, 2007.   
+C. Raffel and D. P. W. Ellis. Large-scale content-based matching of MIDI and audio files. ISMIR, 2015.   
+C. Raffel, B. McFee, E. J. Humphrey, J. Salamon, O. Nieto, D. Liang, and D. P. W. Ellis. mir eval: A transparent implementation of common mir metrics. ISMIR, 2014.   
+C. Raphael. Automatic segmentation of acoustic musical signals using hidden markov models. IEEE Transactions on Pattern Analysis and Machine Intelligence, 1999.   
+O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. C. Berg, and L. Fei-Fei. Imagenet large scale visual recognition challenge. IJCV, 2015.   
+F. Soulez, X. Rodet, and D. Schwarz. Improving polyphonic and poly-instrumental music to score alignment. ISMIR, 2003.   
+K. Tokuda and H. Zen. Directly modeling voiced and unvoiced components in speech waveforms by neural networks. ICASSP, 2016.   
+R. J. Turetsky and D. P. W. Ellis. Ground-truth transcriptions of real music from force-aligned midi syntheses. ISMIR, 2003.   
+A. van den Oord, S. Dieleman, and B. Schrauwen. Deep content-based music recommendation. NIPS, 2013.   
+A. van den Oord, S. Dieleman, H. Zen, K. Simonyan, O. Vinyals, A. Graves, N. Kalchbrenner, A. Senior, and K. Kavukcuoglu. WaveNet: A generative model for raw audio. arXiv preprint, 2016.
+
+# A VALIDATING THE MUSICNET LABELS
+
+We validate the aligned MusicNet labels with a listening test. We create an aural representation of an aligned score-performance pair by mixing a short sine wave into the performance with the frequency indicated by the score at the time indicated by the alignment. We can listen to this mix and, if the alignment is correct, the sine tones will exactly overlay the original performance; if the alignment is incorrect, the mix will sound dissonant.
+
+We have listened to sections of each recording in the aligned dataset: the beginning, several random samples of middle, and the end. Mixes with substantially incorrect alignments were rejected from the dataset. Failed alignments are mostly attributable to mismatches between the midi and the recording. The most common reason for rejection is musical repeats. Classical music often contains sections with indications that they be repeated a second time; in classical music performance culture, it is often acceptable to ignore these directions. If the score and performance make different choices regarding repeats, a mismatch arises. When the score omits a repeat that occurs in the performance, the alignment typically warps over the entire repeated section, with correct alignments before and after. When the score includes an extra repeat, the alignment typically compresses it into very short segment, with correct alignments on either side. We rejected alignments exhibiting either of these issues from the dataset.
+
+From the aligned performances that we deemed sufficiently accurate to admit to the dataset, we randomly sampled 30 clips for more careful annotation and analysis. We weighted the sample to cover a wide coverage of recordings with various instruments, ensemble sizes, and durations. For each sampled performance, we randomly selected a 30 second clip. Using software transforms, it is possible to slow a recording down to approximately 1/4 speed. Two of the clips were too richly structured and fast to precisely analyze (slowing the signal down any further introduces artifacts that make the signal difficult to interpret). Even in these two rejected samples, the alignments sound substantially correct.
+
+For the other 28 clips, we carefully analyzed the aligned performance mix and annotated every alignment error. Two of the authors are classically trained musicians: we independently checked for errors and we our analyses were nearly identical. Where there was disagreement, we used the more pessimistic author’s analysis. Over our entire set of clips we averaged a $4 . 0 \%$ error rate.
+
+Note that we do not catch every type of error. Mistaken note onsets are more easily identified than mistaken offsets. Typically the release of one note coincides with the onset of a new note, which implicitly verifies the release. However, release times at the ends of phrases may be less accurate; these inaccuracies would not be covered by our error analysis. We were also likely to miss performance mistakes that maintain the meter of the performance, but for professional recordings such mistakes are rare.
+
+For stringed instruments, chords consisting of more than two notes are “rolled”; i.e. they are performed serially from the lowest to the highest note. Our alignment protocol cannot separate notes that are notated simultaneously in the score; a rolled chord is labeled with a single starting time, usually the beginning of the first note in the roll. Therefore, there is some time period at the beginning of a roll where the top notes of the chord are labeled but have not yet occurred in the performance. There are reasonable interpretations of labeling under which these labels would be judged incorrect. On the other hand, if the labels are used to supervise transcription then ours is likely the desired labeling.
+
+We can also qualitatively characterize the types of errors we observed. The most common types of errors are anticipations and delays: a single, or small sequence of labels is aligned to a slightly early or late location in the time series. Another common source of error is missing ornaments and trills: these are short flourishes in a performance are sometimes not annotated in our score data, which results in a missing annotation in the alignment. Finally, there are rare performance errors in the recordings and transcription errors in the score.
+
+# B ALIGNMENT PARAMETER ROBUSTNESS
+
+The definitions of audio featurization and the alignment cost function were contingent on several parameter choices. These choices were optimized by systematic exploration of the parameter space. We investigated what happens as we vary each parameter and made the choices that gave the best results in our listening tests. Fine-tuning of the parameters yields marginal gains.
+
+The quality of alignments improves uniformly with the quality of synthesis. The time-resolution of labels improves uniformly as the stride parameter decreases; minimization of stride is limited by system memory constraints. We find that the precise phase-invariant feature specification has little effect on alignment quality. We experimented with spectrograms and log-spectrograms using windowed and un-windowed signals. Alignment quality seemed to be largely unaffected.
+
+The other parameters are governed by a tradeoff curve; the optimal choice is determined by balancing desirable outcomes. The Fourier window size is a classic tradeoff between time and frequency resolution. The $\ell ^ { 2 }$ norm can be understood as a tradeoff between the extremes of $\ell ^ { 1 }$ and $\ell ^ { \infty }$ . The $\bar { \ell ^ { 1 } }$ norm is too egalitarian: the preponderance of errors due to synthesis quality add up and overwhelm the signal. On the other hand, the $\ell ^ { \infty }$ norm ignores too much of the signal in the spectrogram. The spectrogram cutoff, discussed in Sec. 3, is also a tradeoff between synthesis quality and maximal use of information
+
+# C ADDITIONAL ERROR ANALYSIS
+
+For each model, using the test set described in Sect. 5, we report accuracy and error scores used by the MIR community to evaluate the Multi-F0 systems. Definitions and a discussion of these metrics are presented in Poliner & Ellis (2007).
+
+<table><tr><td>Representation</td><td>Acc</td><td>Etot</td><td>Esub</td><td>Emiss</td><td>Efa</td></tr><tr><td>512-point log-spectrogram</td><td>28.5%</td><td>.819</td><td>.198</td><td>.397</td><td>.224</td></tr><tr><td>1024-point log-spectrogram</td><td>33.4%</td><td>.715</td><td>.123</td><td>.457</td><td>.135</td></tr><tr><td>1024-point log-ReLUgram</td><td>35.9%</td><td>.711</td><td>.144</td><td>.377</td><td>.190</td></tr><tr><td>4096-point log-spectrogram</td><td>24.7%</td><td>.788</td><td>.085</td><td>.628</td><td>.074</td></tr><tr><td>8192-point log-spectrogram</td><td>16.1%</td><td>.866</td><td>.082</td><td>.737</td><td>.047</td></tr><tr><td>MLP,500 nodes,2048 raw samples</td><td>36.8%</td><td>.790</td><td>.206</td><td>.214</td><td>.370</td></tr><tr><td>MLP,2500 nodes.2048 samples</td><td>40.4%</td><td>.740</td><td>.177</td><td>.200</td><td>.363</td></tr><tr><td>AvgPool, 5 stride,2048 samples</td><td>40.5%</td><td>.744</td><td>.176</td><td>.200</td><td>.369</td></tr><tr><td>MLP, 500 nodes,16384 samples</td><td>42.0%</td><td>.735</td><td>.160</td><td>.191</td><td>.383</td></tr><tr><td>CNN, 64 stride,16384 samples</td><td>48.9%</td><td>.634</td><td>.117</td><td>.164</td><td>.352</td></tr></table>
+
+Table 4: MIREX-style statistics, evaluated using the mir eval library (Raffel et al., 2014).
+
+# D PRECISION & RECALL CURVES
+
+![](images/810d0e2683165012ba1f572437ab143e35419626c8e35b2f899b24a16e694f2a.jpg)
+
+![](images/1a0e01dc147eafcf87fc9130743d1cac4eae192849d02b9825c44ddcf940b4d3.jpg)  
+Figure 7: The 500 node, 2048 raw sample MLP.
+
+![](images/f52a40cd66e7452be48e128f48fc0bd45d974575f5baf9d6902458c3643fe34b.jpg)  
+Figure 6: The linear spectrogram model.
+
+![](images/4b94c58e9626f3a6dc8ce4c6c4a0a6286876fbf8c1ae181061ea3c19f6c48b3d.jpg)  
+Figure 9: The average pooling model.
+
+![](images/21f2d335f75aff509ef9221e2b73bedf6e9a23f45ac80cc39df7cb777c5e97ea.jpg)  
+Figure 8: The 2500 node, 2048 raw sample MLP.
+
+![](images/bce2c39127cbc1c8dcb726c11d8c6842629ce4d04d7bb6ab33aa4a3118c7d480.jpg)  
+Figure 10: The 500 node, 16384 raw sample MLP.   
+Figure 11: The convolutional model.
+
+# E ADDITIONAL RESULTS
+
+We report additional results on splits of the test set described in Sect. 5.   
+
+<table><tr><td>Model</td><td>Features</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>MLP, 500 nodes</td><td>2048 raw samples</td><td>56.1%</td><td>62.7%</td><td>59.2%</td></tr><tr><td>MLP,2500 nodes</td><td>2048 raw samples</td><td>59.1%</td><td>67.8%</td><td>63.1%</td></tr><tr><td>AvgPool, 5 stride</td><td>2048 raw samples</td><td>59.1%</td><td>68.2%</td><td>64.5%</td></tr><tr><td>MLP, 500 nodes</td><td>16384 raw samples</td><td>60.2%</td><td>65.2%</td><td>65.8%</td></tr><tr><td>CNN, 64 stride</td><td>16384 raw samples</td><td>65.9%</td><td>75.2%</td><td>74.4%</td></tr></table>
+
+Table 5: The Soni Ventorum recording of Mozart’s Wind Quintet K375 (MusicNet id 1819).   
+
+<table><tr><td>Model</td><td>Features</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>MLP, 500 nodes</td><td>2048 raw samples</td><td>35.4%</td><td>40.7%</td><td>28.0%</td></tr><tr><td>MLP,2500 nodes</td><td>2048 raw samples</td><td>38.3%</td><td>44.3%</td><td>30.9%</td></tr><tr><td>AvgPool, 5 stride</td><td>2048 raw samples</td><td>38.6%</td><td>45.2%</td><td>31.7%</td></tr><tr><td>MLP, 500 nodes</td><td>16384 raw samples</td><td>43.4%</td><td>51.3%</td><td>41.0%</td></tr><tr><td>CNN, 64 stride</td><td>16384 raw samples</td><td>51.0%</td><td>57.9%</td><td>49.3%</td></tr></table>
+
+Table 6: The European Archive recording of Beethoven’s String Quartet No. 13 (MusicNet id 2382).   
+
+<table><tr><td>Model</td><td>Features</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>MLP, 500 nodes</td><td>2048 raw samples</td><td>55.6%</td><td>67.4%</td><td>64.1%</td></tr><tr><td>MLP,2500 nodes</td><td>2048 raw samples</td><td>60.1%</td><td>71.3%</td><td>68.6%</td></tr><tr><td>AvgPool, 5 stride</td><td>2048 raw samples</td><td>59.6%</td><td>70.7%</td><td>68.1%</td></tr><tr><td>MLP, 500 nodes</td><td>16384 raw samples</td><td>57.1%</td><td>76.3%</td><td>68.4%</td></tr><tr><td>CNN, 64 stride</td><td>16384 raw samples</td><td>61.9%</td><td>80.1%</td><td>73.9%</td></tr></table>
+
+Table 7: The Kimiko Ishizaka recording of Bach’s Prelude in D major (MusicNet id 2303).

parse/train/rkFBJv9gg/rkFBJv9gg_content_list.json

@@ -0,0 +1,1184 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING FEATURES OF MUSIC FROM SCRATCH ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            763,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "John Thickstun1, Zaid Harchaoui2 & Sham M. Kakade1,2   \n1 Department of Computer Science and Engineering, 2 Department of Statistics   \nUniversity of Washington   \nSeattle, WA 98195, USA   \n{thickstn,sham}@cs.washington.edu, name@uw.edu ",
+        "bbox": [
+            183,
+            143,
+            707,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            252,
+            544,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces a new large-scale music dataset, MusicNet, to serve as a source of supervision and evaluation of machine learning methods for music research. MusicNet consists of hundreds of freely-licensed classical music recordings by 10 composers, written for 11 instruments, together with instrument/note annotations resulting in over 1 million temporal labels on 34 hours of chamber music performances under various studio and microphone conditions. ",
+        "bbox": [
+            233,
+            285,
+            764,
+            367
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The paper defines a multi-label classification task to predict notes in musical recordings, along with an evaluation protocol, and benchmarks several machine learning architectures for this task: i) learning from spectrogram features; ii) endto-end learning with a neural net; iii) end-to-end learning with a convolutional neural net. These experiments show that end-to-end models trained for note prediction learn frequency selective filters as a low-level representation of audio. ",
+        "bbox": [
+            233,
+            371,
+            764,
+            454
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Music research has benefited recently from the effectiveness of machine learning methods on a wide range of problems from music recommendation (van den Oord et al., 2013; McFee & Lanckriet, 2011) to music generation (Hadjeres & Pachet, 2016); see also the recent demos of the Google Magenta project1. As of today, there is no large publicly available labeled dataset for the simple yet challenging task of note prediction for classical music. The MIREX MultiF0 Development Set (Benetos & Dixon, 2011) and the Bach10 dataset (Duan et al., 2011) together contain less than 7 minutes of labeled music. These datasets were designed for method evaluation, not for training supervised learning methods. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This situation stands in contrast to other application domains of machine learning. For instance, in computer vision large labeled datasets such as ImageNet (Russakovsky et al., 2015) are fruitfully used to train end-to-end learning architectures. Learned feature representations have outperformed traditional hand-crafted low-level visual features and lead to tremendous progress for image classification. In (Humphrey et al., 2012), Humphrey, Bello, and LeCun issued a call to action: “Deep architectures often require a large amount of labeled data for supervised training, a luxury music informatics has never really enjoyed. Given the proven success of supervised methods, MIR would likely benefit a good deal from a concentrated effort in the curation of sharable data in a sustainable manner.” ",
+        "bbox": [
+            174,
+            633,
+            825,
+            757
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces a new large labeled dataset, MusicNet, which is publicly available2 as a resource for learning feature representations of music. MusicNet is a corpus of aligned labels on freely-licensed classical music recordings, made possible by licensing initiatives of the European Archive, the Isabella Stewart Gardner Museum, Musopen, and various individual artists. The dataset consists of 34 hours of human-verified aligned recordings, containing a total of 1, 299, 329 individual labels on segments of these recordings. Table 1 summarizes statistics of MusicNet. ",
+        "bbox": [
+            174,
+            765,
+            823,
+            848
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The focus of this paper’s experiments is to learn low-level features of music from raw audio data. In Sect. 4, we will construct a multi-label classification task to predict notes in musical recordings, along with an evaluation protocol. We will consider a variety of machine learning architectures for this task: i) learning from spectrogram features; ii) end-to-end learning with a neural net; iii) endto-end learning with a convolutional neural net. Each of the proposed end-to-end models learns a set of frequency selective filters as low-level features of musical audio, which are similar in spirit to a spectrogram. The learned low-level features are visualized in Figure 1. The learned features modestly outperform spectrogram features; we will explore possible reasons for this in Sect. 5. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            883
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/bc7ca881e893453d0b0321762c0c0fc2d68f7b98fce640bccc362a177ee622d8.jpg",
+        "table_caption": [
+            "MusicNet ",
+            "Table 1: Summary statistics of the MusicNet dataset. See Sect. 2 for further discussion of MusicNet and Sect. 3 for a description of the labelling process. Appendix A discusses the methodology for computing error rate of this process. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td> Minutes</td><td>Labels</td><td>Recordings</td><td>Error Rate</td><td></td><td>Composer</td><td> Minutes</td><td>Labels</td></tr><tr><td>2,048</td><td>1,299,329</td><td>330</td><td colspan=\"2\">4.0%</td><td>Beethoven Schubert</td><td>1,085 253</td><td>736,072</td></tr><tr><td colspan=\"6\">Labels</td><td>192</td><td>133,109</td><td>146,648</td></tr><tr><td colspan=\"6\">Ensemble Minutes Solo Piano 917</td><td>Brahms Mozart Bach</td><td>156</td><td>99,641</td></tr><tr><td colspan=\"6\"> String Quartet</td><td>Dvorak</td><td>184</td><td>62,782</td></tr><tr><td colspan=\"6\"> Accompanied Violin</td><td></td><td>56</td><td>46,261</td></tr><tr><td colspan=\"6\"> Piano Quartet</td><td>Cambini</td><td>43</td><td>24,820</td></tr><tr><td colspan=\"6\"> Accompanied Cello</td><td>Faure</td><td></td><td>22,349</td></tr><tr><td colspan=\"6\"> String Sextet</td><td>Ravel</td><td>27</td><td>21,243</td></tr><tr><td colspan=\"6\">Piano Trio</td><td>Haydn</td><td></td><td>6,404</td></tr><tr><td colspan=\"6\">Piano Quintet</td><td></td><td></td><td></td></tr><tr><td colspan=\"6\">25 Wind Quintet 43</td><td> Instrument</td><td> Minutes</td><td>Labels</td></tr><tr><td colspan=\"6\">Horn Piano Trio 30</td><td>Piano</td><td>1346</td><td>794,532</td></tr><tr><td colspan=\"6\">Wind Octet 23</td><td>Violin</td><td>874</td><td>230,484</td></tr><tr><td colspan=\"6\">Clarinet-Cello-Piano Trio</td><td>Viola</td><td>621</td><td>99,407</td></tr><tr><td colspan=\"6\">2524 Pairs Clarinet-Horn-Bassoon</td><td>Cello</td><td>800</td><td>99,132</td></tr><tr><td colspan=\"6\">Clarinet Quintet 26</td><td>Clarinet</td><td>173</td><td>24,426</td></tr><tr><td colspan=\"6\">Solo Cello 49</td><td>Bassoon</td><td>102</td><td>14,954</td></tr><tr><td colspan=\"6\">Accompanied Clarinet 20</td><td>Horn</td><td>132</td><td>11,468</td></tr><tr><td colspan=\"6\">10,049 Solo Violin 30</td><td>Oboe</td><td>66</td><td></td></tr><tr><td colspan=\"6\">Violin and Harpsichord 16</td><td>Flute</td><td>69</td><td>8,696</td></tr><tr><td colspan=\"6\">Viola Quintet 15</td><td></td><td></td><td>8,310</td></tr><tr><td colspan=\"6\"> Solo Flute</td><td>Harpsichord</td><td>16</td><td>4,914</td></tr><tr><td colspan=\"6\"></td><td> String Bass</td><td>38</td><td>3,006</td></tr><tr><td>Piano</td><td>Violin</td><td>Cello</td><td>Viola</td><td>Clarinet Bassoon</td><td>Horn</td><td>Oboe</td><td></td><td></td><td></td></tr><tr><td colspan=\"6\"></td><td></td><td>Flute</td><td>Bass Harpsichord</td><td></td></tr><tr><td>Notes</td><td>83</td><td>51</td><td>51 51</td><td>41</td><td>36</td><td>41 28</td><td>37</td><td>43</td><td>51</td></tr></table>",
+        "bbox": [
+            192,
+            123,
+            802,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            614,
+            825,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/11de063179b53a961d7c5abb73ccbb146c9b2303b58b47a462d7f6fd90a294d7.jpg",
+        "image_caption": [
+            "Figure 1: (Left) Bottom-level weights learned by a two-layer ReLU network trained on 16,384- samples windows $( \\approx 1 / 3$ seconds) of raw audio with $\\ell _ { 2 }$ regularized $\\lambda = 1$ ) square loss for multilabel note classification on raw audio recordings. (Middle) Magnified view of the center of each set of weights. (Right) The truncated frequency spectrum of each set of weights. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            729,
+            818,
+            851
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MUSICNET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Related Works. The experiments in this paper suggest that large amounts of data are necessary to recovering useful features from music; see Sect. 4.5 for details. The Lakh dataset, released this summer based on the work of Raffel & Ellis (2015), offers note-level annotations for many 30- second clips of pop music in the Million Song Dataset (McFee et al., 2012). The syncRWC dataset is a subset of the RWC dataset (Goto et al., 2003) consisting of 61 recordings aligned to scores using the protocol described in Ewert et al. (2009). The MAPS dataset (Emiya et al., 2010) is a mixture of acoustic and synthesized data, which expressive models could overfit. The Mazurka project3 consists of commercial music. Access to the RWC and Mazurka datasets comes at both a cost and inconvenience. Both the MAPS and Mazurka datasets are comprised entirely of piano music. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            258
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The MusicNet Dataset. MusicNet is a public collection of labels (exemplified in Table 2) for 330 freely-licensed classical music recordings of a variety of instruments arranged in small chamber ensembles under various studio and microphone conditions. The recordings average 6 minutes in length. The shortest recording in the dataset is 55 seconds and the longest is almost 18 minutes. Table 1 summarizes the statistics of MusicNet with breakdowns into various types of labels. Table 2 demonstrates examples of labels from the MusicNet dataset. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/99aae2f0175c09243f437f3df5d2a9a418003cd7acb139fb9169f4c24533f9d5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Start</td><td>End</td><td>Instrument</td><td>Note</td><td>Measure</td><td>Beat</td><td>Note Value</td></tr><tr><td>45.29</td><td>45.49</td><td>Violin</td><td>G5</td><td>21</td><td>3</td><td>Eighth</td></tr><tr><td>48.99</td><td>50.13</td><td>Cello</td><td>A#3</td><td>24</td><td>2</td><td>Dotted Half</td></tr><tr><td>82.91</td><td>83.12</td><td>Viola</td><td>C5</td><td>51</td><td>2.5</td><td>Eighth</td></tr></table>",
+        "bbox": [
+            258,
+            361,
+            740,
+            434
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 2: MusicNet labels on the Pascal String Quartet’s recording of Beethoven’s Opus 127, String Quartet No. 12 in E-flat major, I - Maestoso - Allegro. Creative commons use of this recording is made possible by the work of the European Archive. ",
+        "bbox": [
+            178,
+            444,
+            820,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MusicNet labels come from 513 label classes using the most naive definition of a class: distinct instrument/note combinations. The breakdowns reported in Table 1 indicate the number of distinct notes that appear for each instrument in our dataset. For example, while a piano has 88 keys only 83 of them are performed in MusicNet. For many tasks a note’s value will be a part of its label, in which case the number of classes will expand by approximately an order of magnitude after taking the cartesian product of the set of classes with the set of values: quarter-note, eighth-note, triplet, etc. Labels regularly overlap in the time series, creating polyphonic multi-labels. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MusicNet is skewed towards Beethoven, thanks to the composer’s popularity among performing ensembles. The dataset is also skewed towards Solo Piano due to an abundance of digital scores available for piano works. For training purposes, researchers may want to augment this dataset to increase coverage of instruments such as Flute and Oboe that are under-represented in MusicNet. Commercial recordings could be used for this purpose and labeled using the alignment protocol described in Sect. 3. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DATASET CONSTRUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            708,
+            421,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MusicNet recordings are freely-licensed classical music collected from the European Archive, the Isabella Stewart Gardner Museum, Musopen, and various artists’ collections. The MusicNet labels are retrieved from digital MIDI scores, collected from various archives including the Classical Archives (classicalarchives.com) Suzuchan’s Classic MIDI (suzumidi.com) and HarfeSoft (harfesoft.de). The methods in this section produce an alignment between a digital score and a corresponding freely-licensed recording. A recording is labeled with events in the score, associated to times in the performance via the alignment. Scores containing 6, 550, 760 additional labels are available on request to researchers who wish to augment MusicNet with commercial recordings. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Music-to-score alignment is a long-standing problem in the music research and signal processing communities (Raphael, 1999). Dynamic time warping (DTW) is a classical approach to this problem. An early use of DTW for music alignment is Orio & Schwarz (2001) where a recording is aligned to a crude synthesis of its score, designed to capture some of the structure of an overtone series. The method described in this paper aligns recordings to synthesized performances of scores, using side information from a commercial synthesizer. To the best of our knowledge, commercial synthesis was first used for the purpose of alignment in Turetsky & Ellis (2003). ",
+        "bbox": [
+            176,
+            858,
+            823,
+            901
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The majority of previous work on alignment focuses on pop music. This is more challenging than aligning classical music because commercial synthesizers do a poor job reproducing the wide variety of vocal and instrumental timbers that appear in modern pop. Furthermore, pop features inharmonic instruments such as drums for which natural metrics on frequency representations–including $\\ell ^ { 2 }$ –are not meaningful. For classical music to score alignment, a variant of the techniques described in Turetsky & Ellis (2003) works robustly. This method is described below; we discuss the evaluation of this procedure and its error rate on MusicNet in the appendix. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b140393006a315d552c21453c6ab01f5f4265167475eee6b5afb8c1c125a9a5.jpg",
+        "image_caption": [
+            "Figure 2: (Left) Heatmap visualization of local alignment costs between the synthesized and recorded spectrograms, with the optimal alignment path in red. The block from $x = 0$ to $x = 1 0 0$ frames corresponds to silence at the beginning of the recorded performance. The slope of the alignment can be interpreted as an instantaneous tempo ratio between the recorded and synthesized performances. The curvature in the alignment between $x \\ = \\ 1 0 0$ and $x \\ = \\ 1 7 5$ corresponds to an extension of the first notes by the performer. (Right) Annotation of note onsets on the spectrogram of the recorded performance, determined by the alignment shown on the left. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            285,
+            815,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to align the performance with a score, we need to define a metric that compares short segments of the score with segments of a performance. Musical scores can be expressed as binary vectors in $E \\times K$ where $E = \\{ 1 , \\ldots , n \\}$ and $K$ is a dictionary of notes. Performances reside in $\\mathbb { R } ^ { T \\times p }$ , where $T \\in \\{ 1 , \\dots , m \\}$ is a sequence of time steps and $p$ is the dimensionality of the spectrogram at time $T$ . Given some local cost function $C : ( \\mathbb { R } ^ { p } , K ) \\to \\mathbb { R }$ , a score $\\mathbf { Y } \\in E \\times K$ , and a performance $\\mathbf { X } \\in \\mathbb { R } ^ { T \\times p }$ , the alignment problem is to ",
+        "bbox": [
+            173,
+            551,
+            825,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5c90eda37f5432da38e26c1100b95dd0b120aeaf622db93976483b1ee935f64.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { \\underset { t \\in \\mathbb { Z } ^ { n } } { \\mathrm { m i n i m i z e } } } & { \\displaystyle \\sum _ { i = 1 } ^ { n } C ( \\mathbf { X } _ { t _ { i } } , \\mathbf { Y } _ { i } ) } \\\\ & { \\mathrm { s u b j e c t ~ t o } } & { t _ { 0 } = 0 , } \\\\ & { t _ { n } = m , } \\\\ & { t _ { i } \\leq t _ { j } } & { \\mathrm { i f } i < j . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            642,
+            612,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dynamic time warping gives an exact solution to the problem in $\\mathcal { O } ( m n )$ time and space. ",
+        "bbox": [
+            171,
+            733,
+            753,
+            748
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The success of dynamic time warping depends on the metric used to compare the score and the performance. Previous works can be broadly categorized into three groups that define an alignment cost $C$ between segments of music $\\mathbf { X }$ and score $\\mathbf { y }$ by injecting them into a common normed space via maps $\\Psi$ and $\\Phi$ : ",
+        "bbox": [
+            174,
+            755,
+            823,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/816f167fb6935a395c1df7873fc33bdf2e4f5952ac2677559b80c6a6ced66e67.jpg",
+        "text": "$$\nC ( \\mathbf { x } , \\mathbf { y } ) = \\| \\Psi ( \\mathbf { x } ) - \\Phi ( \\mathbf { y } ) \\|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            810,
+            588,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The most popular approach–and the one adopted by this paper–maps the score into the space of the performance (Orio & Schwarz, 2001; Turetsky $\\&$ Ellis, 2003; Soulez et al., 2003). An alternative approach maps both the score and performance into some third space, commonly a chromogram space (Hu et al., 2003; Izmirli $\\&$ Dannenberg, 2010; Joder et al., 2013). Finally, some recent methods consider alignment in score space, taking $\\Phi = \\mathrm { I d }$ and learning $\\Psi$ (Garreau et al., 2014; Lajugie et al., 2016). ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With reference to the general cost (2), we must specify the maps $\\Psi , \\Phi$ , and the norm $\\| \\cdot \\|$ . We compute the cost in the performance feature space $\\mathbb { R } ^ { p }$ , hence we take $\\Psi = \\mathrm { I d }$ . For the features, we use the log-spectrogram with a window size of 2048 samples. We use a stride of 512 samples between features. Hence adjacent feature frames are computed with $7 5 \\%$ overlap. For audio sampled at $4 4 . 1 \\mathrm { k H z }$ , this results in a feature representation with 4 $\\mathrm { \\Delta } 4 , 1 0 0 / 5 1 2 \\approx 8 6 $ frames per second. A discussion of these parameter choices can be found in the appendix. The map $\\Phi$ is computed by a synthetizer: we used Plogue’s Sforzando sampler together with Garritan’s Personal Orchestra 4 sample library. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For a (pseudo)-metric on $\\mathbb { R } ^ { p }$ , we take the $\\ell ^ { 2 }$ norm $\\| \\cdot \\| _ { 2 }$ on the low 50 dimensions of $\\mathbb { R } ^ { p }$ . Recall that $\\mathbb { R } ^ { p }$ represents Fourier components, so we can roughly interpret the $k$ ’th coordinate of $\\mathbb { R } ^ { p }$ as the energy associated with the frequency $k \\times ( 2 2 , 0 5 0 / \\mathrm { 1 0 2 4 } ) \\approx \\bar { k } \\times 2 2 . 5 \\mathrm { H z }$ , where $2 2 , 0 5 0 \\mathrm { H z }$ is the Nyquist frequency of a signal sampled at $4 4 . 1 \\mathrm { k H z }$ . The 50 dimension cutoff is chosen empirically: we observe that the resulting alignments are more accurate using a small number of low-frequency bins rather than the full space $\\mathbb { R } ^ { p }$ . Synthesizers do not accurately reproduce the high-frequency features of a musical instrument; by ignoring the high frequencies, we align on a part of the spectrum where the synthesis is most accurate. The proposed choice of cutoff is aggressive compared to usual settings; for instance, Turetsky & Ellis (2003) propose cutoffs in the $2 . 5 \\mathrm { k H z }$ range. The fundamental frequencies of many notes in MusicNet are higher than the $5 0 \\times 2 2 . 5 \\mathrm { H z } \\approx 1 \\mathrm { k H z }$ cutoff. Nevertheless, we find that all notes align well using only the low-frequency information. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            395,
+            290,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We consider identification of notes in a segment of audio $\\textbf { x } \\in \\ \\mathcal { X }$ as a multi-label classification problem, modeled as follows. Assign each audio segment a binary label vector $\\mathbf { y } \\in \\{ 0 , 1 \\} ^ { 1 2 8 }$ . The 128 dimensions correspond to frequency codes for notes, and ${ \\bf y } _ { n } = 1$ if note $n$ is present at the midpoint of $\\mathbf { x }$ . Let $f : \\mathcal { X } \\to \\mathcal { H }$ indicate a feature map. We train a multivariate linear regression to predict $\\hat { \\mathbf { y } }$ given $f ( \\mathbf { x } )$ , which we optimize for square loss. The vector $\\hat { \\mathbf { y } }$ can be interpreted as a multi-label estimate of notes in $\\mathbf { x }$ by choosing a threshold $c$ and predicting label $n$ iff ${ \\hat { \\mathbf { y } } } _ { n } > c$ . We search for the value $c$ that maximizes $F _ { 1 }$ -score on a sampled subset of MusicNet. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            525
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            330,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning on raw audio is studied in both the music and speech communities. Supervised learning on music has been driven by access to labeled datasets. Pop music labeled with chords (Harte, 2010) has lead to a long line of work on chord recognition, most recently Korzeniowsk & Widmer (2016). Genre labels and other metadata has also attracted work on representation learning, for example Dieleman & Schrauwen (2014). There is also substantial work modeling raw audio representations of speech; a current example is Tokuda & Zen (2016). Recent work from Google DeepMind explores generative models of raw audio, applied to both speech and music (van den Oord et al., 2016). ",
+        "bbox": [
+            174,
+            566,
+            825,
+            665
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The music community has worked extensively on a closely related problem to note prediction: fundamental frequency estimation. This is the analysis of fundamental (in contrast to overtone) frequencies in short audio segments; these frequencies are typically considered as proxies for notes. Because access to large labeled datasets was historically limited, most of these works are unsupervised. A good overview of this literature can be found in Benetos et al. (2013). Variants of non-negative matrix factorization are popular for this task; a recent example is Khlif & Sethu (2015). A different line of work models audio probabilistically, for example Berg-Kirkpatrick et al. (2014). Recent work by Kelz et al. (2016) explores supervised models, trained using the MAPS piano dataset. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 MULTI-LAYER PERCEPTRONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            416,
+            814
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We build a two-layer network with features $f _ { i } ( \\mathbf { x } ) = \\log \\left( 1 + \\operatorname* { m a x } ( 0 , \\mathbf { w } _ { i } ^ { T } \\mathbf { x } ) \\right)$ . We find that compression introduced by a logarithm improves performance versus a standard ReLU network (see Table 3). Figure 1 illustrates a selection of weights $w _ { i }$ learned by the bottom layer of this network. The weights learned by the network are modulated sinusoids. This explains the effectiveness of spectrograms as a low-level representation of musical audio. The weights decay at the boundaries, analogous to Gabor filters in vision. This behavior is explained by the labeling methodology: the audio segments used here are approximately $1 / 3$ of a second long, and a segment is given a note label if that note is on in the center of the segment. Therefore information at the boundaries of the segment is less useful for prediction than information nearer to the center. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 (LOG-)SPECTROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            379,
+            162
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Spectrograms are an engineered feature representation for musical audio signals, available in popular software packages such as librosa (McFee et al., 2015). Spectrograms (resp. log-spectrograms) are closely related to a two-layer ReLU network (resp. the log-ReLU network described above). If $\\mathbf { x } = ( x _ { 1 } , \\dots , x _ { t } )$ denotes a segment of an audio signal of length $t$ then we can define ",
+        "bbox": [
+            176,
+            174,
+            825,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bac2a1bd7a66f750ac4ef057d2fa819f4790063de72c4af6545605da9e04829.jpg",
+        "text": "$$\n\\mathrm { S p e c } _ { k } ( \\mathbf { x } ) \\equiv \\left| \\sum _ { s = 0 } ^ { t - 1 } e ^ { - 2 \\pi i k s / t } x _ { s } \\right| ^ { 2 } = \\left( \\sum _ { s = 0 } ^ { t - 1 } \\cos ( 2 \\pi k s / t ) x _ { s } \\right) ^ { 2 } + \\left( \\sum _ { s = 0 } ^ { t - 1 } \\sin ( 2 \\pi k s / t ) x _ { s } \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            234,
+            787,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "These features are not precisely learnable by a two-layer ReLU network. But recall that $| x | =$ $\\operatorname* { m a x } ( 0 , x ) + \\operatorname* { m a x } ( 0 , - \\bar { x } )$ and if we take weight vectors ${ \\bf u } , { \\bf v } \\in \\mathbb { R } ^ { T }$ with $u _ { s } = \\cos ( 2 \\pi k s / t )$ and $v _ { s } = \\sin ( 2 \\pi k s / t )$ then the ReLU network can learn ",
+        "bbox": [
+            173,
+            291,
+            826,
+            334
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b0e9ec100214b3d8fa6fdcf534f78f9f3619c84cbbcfb015c330f2d8f2a3f88.jpg",
+        "text": "$$\nf _ { k , \\mathrm { c o s } } ( \\mathbf { x } ) + f _ { k , \\mathrm { s i n } } ( \\mathbf { x } ) \\equiv | \\mathbf { u } ^ { T } \\mathbf { x } | + | \\mathbf { v } ^ { T } \\mathbf { x } | = \\left| \\sum _ { s = 0 } ^ { t - 1 } \\mathrm { c o s } ( 2 \\pi k s / t ) x _ { s } \\right| + \\left| \\sum _ { s = 0 } ^ { t - 1 } \\mathrm { s i n } ( 2 \\pi k s / t ) x _ { s } \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            338,
+            789,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We call this family of features a ReLUgram and observe that it has a similar form to the spectrogram; we merely replace the $x \\mapsto x ^ { 2 }$ non-linearity of the spectrogram with $x \\mapsto | x |$ . These features achieve similar performance to spectrograms on the classification task (see Table 3). ",
+        "bbox": [
+            176,
+            385,
+            823,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 WINDOW SIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            443,
+            316,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When we parameterize a network, we must choose the width of the set of weights in the bottom layer. This width is called the receptive field in the vision community; in the music community it is called the window size. Traditional frequency analyses, including spectrograms, are highly sensitive to the window size. Windows must be long enough to capture relevant information, but not so long that they lose temporal resolution; this is the classical time-frequency tradeoff. Furthermore, windowed frequency analysis is subject to boundary effects, known as spectral leakage. Classical signal processing attempts to dampen these effects with predefined window functions, which apply a mask that attenuates the signal at the boundaries (Rabiner & Schafer, 2007). ",
+        "bbox": [
+            174,
+            469,
+            825,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proposed end-to-end models learn window functions. If we parameterize these models with a large window size then the model will learn that distant information is irrelevant to local prediction, so the magnitude of the learned weights will attenuate at the boundaries. We therefore focus on two window sizes: 2048 samples, which captures the local content of the signal, and 16,384 samples, which is sufficient to capture almost all relevant context (again see Figure 1). ",
+        "bbox": [
+            174,
+            587,
+            825,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.5 REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            341,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The size of MusicNet is essential to achieving the results in Figure 1. In Figure 3 (Left) we optimize a two-layer ReLU network on a small subset of MusicNet consisting of 65, 000 monophonic data points. While these features do exhibit dominant frequencies, the signal is quite noisy. Comparable noisy frequency selective features were recovered by Dieleman & Schrauwen (2014); see their Figure 3. We can recover clean features on a small dataset using heavy regularization, but this destroys classification performance; regularizing with dropout poses a similar tradeoff. By contrast, Figure 3 (Right) shows weights learned by an unregularized two-layer network trained on the full MusicNet dataset. The models described in this paper do not overfit to MusicNet and optimal performance (reported in Table 3) is achieved without regularization. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.6 CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            421,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Previously, we estimated $\\hat { \\mathbf { y } }$ by regressing against $f ( \\mathbf { x } )$ . We now consider a convolutional model that regresses against features of a collection of shifted segments $\\mathbf { x } _ { \\ell }$ near to the original segment x. The learned features of this network are visually comparable to those learned by the fully connected network (Figure 1). The parameters of this network are the receptive field, stride, and pooling regions. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c0669fca76136809bc2d927779736f34a74a909811dd646afdbc2c66b15c673.jpg",
+        "image_caption": [
+            "Figure 3: (Left) Features learned by a 2-layer ReLU network trained on small monophonic subset of MusicNet. (Right) Features learned by the same network, trained on the full MusicNet dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            103,
+            771,
+            246
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results reported in Table 3 are achieved with 500 hidden units using a receptive field of 2, 048 samples with an 8-sample stride across a window of 16, 384 samples. These features are grouped into average pools of width 16, with a stride of 8 features between pools. A max-pooling operation yields similar results. The learned features are consistent across different parameterizations. In all cases the learned features are comparable to those of a fully connected network. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            401,
+            282,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We hold out a test set of 3 recordings for all the results reported in this section: ",
+        "bbox": [
+            173,
+            433,
+            691,
+            448
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Bach’s Prelude in D major for Solo Piano. WTK Book 1, No 5. Performed by Kimiko Ishizaka. MusicNet recording id 2303.   \n• Mozart’s Serenade in E-flat major. K375, Movement 4 - Menuetto. Performed by the Soni Ventorum Wind Quintet. MusicNet recording id 1819.   \n• Beethoven’s String Quartet No. 13 in B-flat major. Opus 130, Movement 2 - Presto. Released by the European Archive. MusicNet recording id 2382. ",
+        "bbox": [
+            215,
+            453,
+            825,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The test set is a representative sampling of MusicNet: it covers most of the instruments in the dataset in small, medium, and large ensembles. The test data points are evenly spaced segments separated by 512 samples, between the 1st and 91st seconds of each recording. For the wider features, there is substantial overlap between adjacent segments. Each segment is labeled with the notes that are on in the middle of the segment. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/11641190697d2c62117bfa33adfae72bd0e1b39586d981eba8920ed2506e51c4.jpg",
+        "image_caption": [
+            "Figure 4: Precision-recall curves for the convolutional network on the test set. Curves are evaluated on subsets of the test set consisting of all data points (blue); points with exactly one label (monophonic; green); and points with exactly three labels (red). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            636,
+            678,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our models on three scores: precision, recall, and average precision. The precision score is the count of correct predictions by the model (across all data points) divided by the total number of predictions by the model. The recall score is the count of correct predictions by the model divided by the total number of (ground truth) labels in the test set. Precision and recall are parameterized by the note prediction threshold $c$ (see Sect. 4). By varying $c$ , we construct precision-recall curves (see Figure 4). The average precision score is the area under the precision-recall curve. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c39c4f354572f518882f2760616b9919ee2dbaadb2c1c73fafeded6443fd6487.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Representation</td><td>Window Size</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>log-spectrograms</td><td>1,024</td><td>49.0%</td><td>40.5%</td><td>39.8%</td></tr><tr><td>spectrograms</td><td>2,048</td><td>28.9%</td><td>52.5 %</td><td>32.9%</td></tr><tr><td>log-spectrograms</td><td>2,048</td><td>61.9%</td><td>42.0%</td><td>48.8%</td></tr><tr><td>log-ReLUgrams</td><td>2.048</td><td>58.9%</td><td>47.9%</td><td>49.3%</td></tr><tr><td>MLP,500 nodes</td><td>2.048</td><td>50.1%</td><td>58.0%</td><td>52.1%</td></tr><tr><td>MLP, 2500 nodes</td><td>2.048</td><td>53.6%</td><td>62.3%</td><td>56.2%</td></tr><tr><td>AvgPool,2 stride</td><td>2,148</td><td>53.4%</td><td>62.5%</td><td>56.4%</td></tr><tr><td>log-spectrograms</td><td>8,192</td><td>64.2%</td><td>28.6%</td><td>52.1%</td></tr><tr><td>log-spectrograms</td><td>16,384</td><td>58.4%</td><td>18.1%</td><td>45.5%</td></tr><tr><td>MLP, 500 nodes</td><td>16,384</td><td>54.4%</td><td>64.8%</td><td>60.0%</td></tr><tr><td>CNN, 64 stride</td><td>16,384</td><td>60.5%</td><td>71.9%</td><td>67.8%</td></tr></table>",
+        "bbox": [
+            233,
+            178,
+            763,
+            361
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Benchmark results on MusicNet for models discussed in this paper. The learned representations are optimized for square loss with SGD using the Tensorflow library (Abadi et al.). We report the precision and recall corresponding to the best $F _ { 1 }$ -score on validation data. ",
+        "bbox": [
+            174,
+            371,
+            823,
+            414
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A spectrogram of length $n$ is computed from $2 n$ samples, so the linear 1024-point spectrogram model is directly comparable to the MLP runs with 2048 raw samples. Learned features4 modestly outperform spectrograms for comparable window sizes. The discussion of windowing in Sect. 4.4 partially explains this. Figure 5 suggests a second reason. Recall (Sect. 4.3) that the spectrogram features can be interpreted as the magnitude of the signal’s inner product with sine waves of linearly spaced frequencies. In contrast, the proposed networks learn weights with frequencies distributed similarly to the distribution of notes in MusicNet (Figure 5). This gives the network higher resolution in the most critical frequency regions. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            547
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/515e332fb787091151cc1fe1f015f9b0c0daa6c8d967fc5e24577abcd6ab5653.jpg",
+        "image_caption": [
+            "Figure 5: (Left) The frequency distribution of notes in MusicNet. (Right) The frequency distribution of learned nodes in a 500-node, two-layer ReLU network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            571,
+            779,
+            709
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            794,
+            326,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We thank Bob L. Sturm for his detailed feedback on an earlier version of the paper. We also thank Brian McFee and Colin Raffel for fruitful discussions. Sham Kakade acknowledges funding from the Washington Research Foundation for innovation in Data-intensive Discovery. Zaid Harchaoui acknowledges funding from the program ”Learning in Machines and Brains” of CIFAR. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nM. Abadi, A. Agarwal, P. Barham, E. Brevdo, Z. Chen, C. Citro, G. Corrado, A. Davis, J. Dean, M. Devin, S. Ghemawat, I. Goodfellow, A. Harp, G. Irving, M. Isard, Y. Jia, R. Jozefowicz, L. Kaiser, M. Kudlur, J. Levenberg, D. Mane, R. Monga, S. Moore, D. Murray, C. Olah, M. Schuster, J. Shlens, B. Steiner, I. Sutskever, K. Talwar, P. Tucker, V. Vanhoucke, V. Vasudevan, F. Viegas, O. Vinyals, P. Warden, M. Wattenberg, M. Wicke, Y. Yu, and X. Zheng. TensorFlow: Largescale machine learning on heterogeneous systems. URL http://tensorflow.org/.   \nE. Benetos and S. Dixon. Joint multi-pitch detection using harmonic envelope estimation for polyphonic music transcription. IEEE Selected Topics in Signal Processing, 2011.   \nE. Benetos, S. Dixon, D. Giannoulis, H. Kirchoff, and A. Klapuri. Automatic music transcription: challenges and future directions. Journal of Intelligent Information Systems, 2013.   \nT. Berg-Kirkpatrick, J. Andreas, and D. Klein. Unsupervised transcription of piano music. NIPS, 2014.   \nS. Dieleman and B. Schrauwen. End-to-end learning for music audio. ICASSP, 2014.   \nZ. Duan, B. Pardo, and C. Zhang. Multiple fundamental frequency estimation by modeling spectral peaks and non-peak regions. TASLP, 2011.   \nV. Emiya, R. Badeau, and B. David. Multipitch estimation of piano sounds using a new probabilistic spectral smoothness principle. TASLP, 2010.   \nS. Ewert, M. Muller, and P. Grosche. High resolution audio synchronization using chroma features. ¨ ICASSP, 2009.   \nD. Garreau, R. Lajugie, S. Arlot, and F. Bach. Metric learning for temporal sequence alignment. NIPS, 2014.   \nM. Goto, H. Hashiguchi, T. Nishimura, and R. Oka. RWC music database: Music genre database and musical instrument sound database. ISMIR, 2003.   \nGaetan Hadjeres and Franc¸ois Pachet. Deepbach: a steerable model for bach chorales generation. ¨ arXiv preprint, 2016.   \nC. Harte. Towards Automatic Extraction of Harmony Information from Music Signals. PhD thesis, Department of Electrical Engineering, Queen Mary, University of London, 2010.   \nN. Hu, R. B. Dannenberg, and G. Tzanetakis. Polyphonic audio matching and alignment for music retrieval. IEEE Workshop on Applications of Signal Processing to Audio and Acoustics, 2003.   \nE. J. Humphrey, J. P. Bello, and Y. LeCun. Moving beyond feature design: Deep architectures and automatic feature learning in music informatics. ISMIR, 2012.   \nO. Izmirli and R. B. Dannenberg. Understanding features and distance functions for music sequence alignment. ISMIR, 2010.   \nC. Joder, S. Essid, and G. Richard. Learning optimal features for polyphonic audio-to-score alignment. TASLP, 2013.   \nR. Kelz, M. Dorfer, F. Korzeniowski, S. Bock, A. Arzt, and G. Widmer. On the potential of simple ¨ framewise approaches to piano transcription. ISMIR, 2016.   \nA. Khlif and V. Sethu. An iterative multi range non-negative matrix factorization algorithm for polyphonic music transcription. ISMIR, 2015.   \nF. Korzeniowsk and G. Widmer. Feature learning for chord recognition: the deep chroma extractor. ISMIR, 2016.   \nR. Lajugie, P. Bojanowski, P. Cuvillier, S. Arlot, and F. Bach. A weakly-supervised discriminative model for audio-to-score alignment. ICASSP, 2016.   \nB. McFee and G. Lanckriet. Learning multi-modal similarity. JMLR, 2011.   \nB. McFee, T. Bertin-Mahieux, D. P. W. Ellis, and G. Lanckriet. The million song dataset challenge. Proceedings of the 21st International Conference on World Wide Web, 2012.   \nB. McFee, C. Raffel, D. Liang, D. P. W. Ellis, M. McVicar, E. Battenberg, and O. Nieto. librosa: Audio and music signal analysis in python. SCIPY, 2015.   \nN. Orio and D. Schwarz. Alignment of monophonic and polyphonic music to a score. International Computer Music Conference, 2001.   \nG. Poliner and D. P. W. Ellis. A discriminative model for polyphonic piano transcription. EURASIP Journal on Applied Signal Processing, 2007.   \nL. Rabiner and R. Schafer. Introduction to digital speech processing. Foundations and trends in signal processing, 2007.   \nC. Raffel and D. P. W. Ellis. Large-scale content-based matching of MIDI and audio files. ISMIR, 2015.   \nC. Raffel, B. McFee, E. J. Humphrey, J. Salamon, O. Nieto, D. Liang, and D. P. W. Ellis. mir eval: A transparent implementation of common mir metrics. ISMIR, 2014.   \nC. Raphael. Automatic segmentation of acoustic musical signals using hidden markov models. IEEE Transactions on Pattern Analysis and Machine Intelligence, 1999.   \nO. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. C. Berg, and L. Fei-Fei. Imagenet large scale visual recognition challenge. IJCV, 2015.   \nF. Soulez, X. Rodet, and D. Schwarz. Improving polyphonic and poly-instrumental music to score alignment. ISMIR, 2003.   \nK. Tokuda and H. Zen. Directly modeling voiced and unvoiced components in speech waveforms by neural networks. ICASSP, 2016.   \nR. J. Turetsky and D. P. W. Ellis. Ground-truth transcriptions of real music from force-aligned midi syntheses. ISMIR, 2003.   \nA. van den Oord, S. Dieleman, and B. Schrauwen. Deep content-based music recommendation. NIPS, 2013.   \nA. van den Oord, S. Dieleman, H. Zen, K. Simonyan, O. Vinyals, A. Graves, N. Kalchbrenner, A. Senior, and K. Kavukcuoglu. WaveNet: A generative model for raw audio. arXiv preprint, 2016. ",
+        "bbox": [
+            171,
+            97,
+            826,
+            930
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            85,
+            828,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A VALIDATING THE MUSICNET LABELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            522,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We validate the aligned MusicNet labels with a listening test. We create an aural representation of an aligned score-performance pair by mixing a short sine wave into the performance with the frequency indicated by the score at the time indicated by the alignment. We can listen to this mix and, if the alignment is correct, the sine tones will exactly overlay the original performance; if the alignment is incorrect, the mix will sound dissonant. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            203
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We have listened to sections of each recording in the aligned dataset: the beginning, several random samples of middle, and the end. Mixes with substantially incorrect alignments were rejected from the dataset. Failed alignments are mostly attributable to mismatches between the midi and the recording. The most common reason for rejection is musical repeats. Classical music often contains sections with indications that they be repeated a second time; in classical music performance culture, it is often acceptable to ignore these directions. If the score and performance make different choices regarding repeats, a mismatch arises. When the score omits a repeat that occurs in the performance, the alignment typically warps over the entire repeated section, with correct alignments before and after. When the score includes an extra repeat, the alignment typically compresses it into very short segment, with correct alignments on either side. We rejected alignments exhibiting either of these issues from the dataset. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "From the aligned performances that we deemed sufficiently accurate to admit to the dataset, we randomly sampled 30 clips for more careful annotation and analysis. We weighted the sample to cover a wide coverage of recordings with various instruments, ensemble sizes, and durations. For each sampled performance, we randomly selected a 30 second clip. Using software transforms, it is possible to slow a recording down to approximately 1/4 speed. Two of the clips were too richly structured and fast to precisely analyze (slowing the signal down any further introduces artifacts that make the signal difficult to interpret). Even in these two rejected samples, the alignments sound substantially correct. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            481
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the other 28 clips, we carefully analyzed the aligned performance mix and annotated every alignment error. Two of the authors are classically trained musicians: we independently checked for errors and we our analyses were nearly identical. Where there was disagreement, we used the more pessimistic author’s analysis. Over our entire set of clips we averaged a $4 . 0 \\%$ error rate. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            544
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Note that we do not catch every type of error. Mistaken note onsets are more easily identified than mistaken offsets. Typically the release of one note coincides with the onset of a new note, which implicitly verifies the release. However, release times at the ends of phrases may be less accurate; these inaccuracies would not be covered by our error analysis. We were also likely to miss performance mistakes that maintain the meter of the performance, but for professional recordings such mistakes are rare. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            635
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For stringed instruments, chords consisting of more than two notes are “rolled”; i.e. they are performed serially from the lowest to the highest note. Our alignment protocol cannot separate notes that are notated simultaneously in the score; a rolled chord is labeled with a single starting time, usually the beginning of the first note in the roll. Therefore, there is some time period at the beginning of a roll where the top notes of the chord are labeled but have not yet occurred in the performance. There are reasonable interpretations of labeling under which these labels would be judged incorrect. On the other hand, if the labels are used to supervise transcription then ours is likely the desired labeling. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            753
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We can also qualitatively characterize the types of errors we observed. The most common types of errors are anticipations and delays: a single, or small sequence of labels is aligned to a slightly early or late location in the time series. Another common source of error is missing ornaments and trills: these are short flourishes in a performance are sometimes not annotated in our score data, which results in a missing annotation in the alignment. Finally, there are rare performance errors in the recordings and transcription errors in the score. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            843
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B ALIGNMENT PARAMETER ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            539,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The definitions of audio featurization and the alignment cost function were contingent on several parameter choices. These choices were optimized by systematic exploration of the parameter space. We investigated what happens as we vary each parameter and made the choices that gave the best results in our listening tests. Fine-tuning of the parameters yields marginal gains. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            189
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The quality of alignments improves uniformly with the quality of synthesis. The time-resolution of labels improves uniformly as the stride parameter decreases; minimization of stride is limited by system memory constraints. We find that the precise phase-invariant feature specification has little effect on alignment quality. We experimented with spectrograms and log-spectrograms using windowed and un-windowed signals. Alignment quality seemed to be largely unaffected. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            266
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The other parameters are governed by a tradeoff curve; the optimal choice is determined by balancing desirable outcomes. The Fourier window size is a classic tradeoff between time and frequency resolution. The $\\ell ^ { 2 }$ norm can be understood as a tradeoff between the extremes of $\\ell ^ { 1 }$ and $\\ell ^ { \\infty }$ . The $\\bar { \\ell ^ { 1 } }$ norm is too egalitarian: the preponderance of errors due to synthesis quality add up and overwhelm the signal. On the other hand, the $\\ell ^ { \\infty }$ norm ignores too much of the signal in the spectrogram. The spectrogram cutoff, discussed in Sec. 3, is also a tradeoff between synthesis quality and maximal use of information ",
+        "bbox": [
+            174,
+            272,
+            825,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL ERROR ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            391,
+            472,
+            407
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For each model, using the test set described in Sect. 5, we report accuracy and error scores used by the MIR community to evaluate the Multi-F0 systems. Definitions and a discussion of these metrics are presented in Poliner & Ellis (2007). ",
+        "bbox": [
+            174,
+            422,
+            825,
+            464
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/439d8c687c866f716c89dcc24e174ee89d24d06ce7050ab18e929198cc998f9d.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: MIREX-style statistics, evaluated using the mir eval library (Raffel et al., 2014). "
+        ],
+        "table_body": "<table><tr><td>Representation</td><td>Acc</td><td>Etot</td><td>Esub</td><td>Emiss</td><td>Efa</td></tr><tr><td>512-point log-spectrogram</td><td>28.5%</td><td>.819</td><td>.198</td><td>.397</td><td>.224</td></tr><tr><td>1024-point log-spectrogram</td><td>33.4%</td><td>.715</td><td>.123</td><td>.457</td><td>.135</td></tr><tr><td>1024-point log-ReLUgram</td><td>35.9%</td><td>.711</td><td>.144</td><td>.377</td><td>.190</td></tr><tr><td>4096-point log-spectrogram</td><td>24.7%</td><td>.788</td><td>.085</td><td>.628</td><td>.074</td></tr><tr><td>8192-point log-spectrogram</td><td>16.1%</td><td>.866</td><td>.082</td><td>.737</td><td>.047</td></tr><tr><td>MLP,500 nodes,2048 raw samples</td><td>36.8%</td><td>.790</td><td>.206</td><td>.214</td><td>.370</td></tr><tr><td>MLP,2500 nodes.2048 samples</td><td>40.4%</td><td>.740</td><td>.177</td><td>.200</td><td>.363</td></tr><tr><td>AvgPool, 5 stride,2048 samples</td><td>40.5%</td><td>.744</td><td>.176</td><td>.200</td><td>.369</td></tr><tr><td>MLP, 500 nodes,16384 samples</td><td>42.0%</td><td>.735</td><td>.160</td><td>.191</td><td>.383</td></tr><tr><td>CNN, 64 stride,16384 samples</td><td>48.9%</td><td>.634</td><td>.117</td><td>.164</td><td>.352</td></tr></table>",
+        "bbox": [
+            236,
+            478,
+            761,
+            646
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D PRECISION & RECALL CURVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            472,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/810d0e2683165012ba1f572437ab143e35419626c8e35b2f899b24a16e694f2a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            142,
+            486,
+            291
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a0e01dc147eafcf87fc9130743d1cac4eae192849d02b9825c44ddcf940b4d3.jpg",
+        "image_caption": [
+            "Figure 7: The 500 node, 2048 raw sample MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            143,
+            802,
+            291
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/f52a40cd66e7452be48e128f48fc0bd45d974575f5baf9d6902458c3643fe34b.jpg",
+        "image_caption": [
+            "Figure 6: The linear spectrogram model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            344,
+            486,
+            493
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b94c58e9626f3a6dc8ce4c6c4a0a6286876fbf8c1ae181061ea3c19f6c48b3d.jpg",
+        "image_caption": [
+            "Figure 9: The average pooling model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            345,
+            803,
+            493
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/21f2d335f75aff509ef9221e2b73bedf6e9a23f45ac80cc39df7cb777c5e97ea.jpg",
+        "image_caption": [
+            "Figure 8: The 2500 node, 2048 raw sample MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            546,
+            486,
+            694
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/bce2c39127cbc1c8dcb726c11d8c6842629ce4d04d7bb6ab33aa4a3118c7d480.jpg",
+        "image_caption": [
+            "Figure 10: The 500 node, 16384 raw sample MLP. ",
+            "Figure 11: The convolutional model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            546,
+            803,
+            694
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/211b67fde0060ee363a09d76c7a3da435e190b08ac3dc3da2e8e795197bbc798.jpg",
+        "table_caption": [
+            "We report additional results on splits of the test set described in Sect. 5. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Features</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>MLP, 500 nodes</td><td>2048 raw samples</td><td>56.1%</td><td>62.7%</td><td>59.2%</td></tr><tr><td>MLP,2500 nodes</td><td>2048 raw samples</td><td>59.1%</td><td>67.8%</td><td>63.1%</td></tr><tr><td>AvgPool, 5 stride</td><td>2048 raw samples</td><td>59.1%</td><td>68.2%</td><td>64.5%</td></tr><tr><td>MLP, 500 nodes</td><td>16384 raw samples</td><td>60.2%</td><td>65.2%</td><td>65.8%</td></tr><tr><td>CNN, 64 stride</td><td>16384 raw samples</td><td>65.9%</td><td>75.2%</td><td>74.4%</td></tr></table>",
+        "bbox": [
+            217,
+            161,
+            781,
+            261
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/c33951435a558c8a8d5d702195bd62728ab718bd26255a9b4703ad853600aa8a.jpg",
+        "table_caption": [
+            "Table 5: The Soni Ventorum recording of Mozart’s Wind Quintet K375 (MusicNet id 1819). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Features</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>MLP, 500 nodes</td><td>2048 raw samples</td><td>35.4%</td><td>40.7%</td><td>28.0%</td></tr><tr><td>MLP,2500 nodes</td><td>2048 raw samples</td><td>38.3%</td><td>44.3%</td><td>30.9%</td></tr><tr><td>AvgPool, 5 stride</td><td>2048 raw samples</td><td>38.6%</td><td>45.2%</td><td>31.7%</td></tr><tr><td>MLP, 500 nodes</td><td>16384 raw samples</td><td>43.4%</td><td>51.3%</td><td>41.0%</td></tr><tr><td>CNN, 64 stride</td><td>16384 raw samples</td><td>51.0%</td><td>57.9%</td><td>49.3%</td></tr></table>",
+        "bbox": [
+            218,
+            308,
+            781,
+            407
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/6c1954c41e6e24cfd07954a86733439aedc2c195222f6ac0e3ebd20806e7181a.jpg",
+        "table_caption": [
+            "Table 6: The European Archive recording of Beethoven’s String Quartet No. 13 (MusicNet id 2382). "
+        ],
+        "table_footnote": [
+            "Table 7: The Kimiko Ishizaka recording of Bach’s Prelude in D major (MusicNet id 2303). "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Features</td><td>Precision</td><td>Recall</td><td>Average Precision</td></tr><tr><td>MLP, 500 nodes</td><td>2048 raw samples</td><td>55.6%</td><td>67.4%</td><td>64.1%</td></tr><tr><td>MLP,2500 nodes</td><td>2048 raw samples</td><td>60.1%</td><td>71.3%</td><td>68.6%</td></tr><tr><td>AvgPool, 5 stride</td><td>2048 raw samples</td><td>59.6%</td><td>70.7%</td><td>68.1%</td></tr><tr><td>MLP, 500 nodes</td><td>16384 raw samples</td><td>57.1%</td><td>76.3%</td><td>68.4%</td></tr><tr><td>CNN, 64 stride</td><td>16384 raw samples</td><td>61.9%</td><td>80.1%</td><td>73.9%</td></tr></table>",
+        "bbox": [
+            217,
+            454,
+            781,
+            554
+        ],
+        "page_idx": 13
+    }
+]