Add files using upload-large-folder tool

parse/train/H1e572A5tQ/H1e572A5tQ.md

@@ -0,0 +1,233 @@
+# TARMAC: TARGETED MULTI-AGENT COMMUNICATION
+
+# Anonymous authors
+
+Paper under double-blind review
+
+# ABSTRACT
+
+We explore a collaborative multi-agent reinforcement learning setting where a team of agents attempts to solve cooperative tasks in partially-observable environments. In this scenario, learning an effective communication protocol is key. We propose a communication architecture that allows for targeted communication, where agents learn both what messages to send and who to send them to, solely from downstream task-specific reward without any communication supervision.
+
+Additionally, we introduce a multi-stage communication approach where the agents co-ordinate via multiple rounds of communication before taking actions in the environment. We evaluate our approach on a diverse set of cooperative multi-agent tasks, of varying difficulties, with varying number of agents, in a variety of environments ranging from 2D grid layouts of shapes and simulated traffic junctions to complex 3D indoor environments. We demonstrate the benefits of targeted as well as multi-stage communication. Moreover, we show that the targeted communication strategies learned by agents are both interpretable and intuitive.
+
+# 1 INTRODUCTION
+
+Effective communication is a key ability for collaborative multi-agents systems. Indeed, intelligent agents (humans or artificial) in real-world scenarios can significantly benefit from exchanging information that enables them to coordinate, strategize, and utilize their combined sensory experiences to act in the physical world. The ability to communicate has wide-ranging applications for artificial agents – from multi-player gameplay in simulated games (e.g. DoTA, Quake, StarCraft) or physical worlds (e.g. robot soccer), to networks of self-driving cars communicating with each other to achieve safe and swift transport, to teams of robots on search-and-rescue missions deployed in hostile and fast-evolving environments.
+
+A salient property of human communication is the ability to hold targeted interactions. Rather than the ‘one-size-fits-all’ approach of broadcasting messages to all participating agents, as has been previously explored (Sukhbaatar et al., 2016; Foerster et al., 2016), it can be useful to direct certain messages to specific recipients. This enables a more flexible collaboration strategy in complex environments. For example, within a team of search-and-rescue robots with a diverse set of roles and goals, a message for a fire-fighter (“smoke is coming from the kitchen”) is largely meaningless for a bomb-defuser.
+
+In this work we develop a collaborative multi-agent deep reinforcement learning approach that supports targeted communication. Crucially, each individual agent actively selects which other agents to send messages to. This targeted communication behavior is operationalized via a simple signaturebased soft attention mechanism: along with the message, the sender broadcasts a key which encodes properties of agents the message is intended for, and is used by receivers to gauge the relevance of the message. This communication mechanism is learned implicitly, without any attention supervision, as a result of end-to-end training using a downstream task-specific team reward.
+
+The inductive bias provided by soft attention in the communication architecture is sufficient to enable agents to 1) communicate agent-goal-specific messages (e.g. guide fire-fighter towards fire, bomb-defuser towards bomb, etc.), 2) be adaptive to variable team sizes (e.g. the size of the local neighborhood a self-driving car can communicate with changes as it moves), and 3) be interpretable through predicted attention probabilities that allow for inspection of which agent is communicating what message and to whom.
+
+Our results however show that just using targeted communication is not enough. Complex realworld tasks might require large populations of agents to go through multiple stages of collaborative communication and reasoning, involving large amounts of information to be persistent in memory and exchanged via high-bandwidth communication channels. To this end, our actor-critic framework combines centralized training with decentralized execution (Lowe et al., 2017), thus enabling scaling to a large number of agents. In this context, our inter-agent communication architecture supports multiple stages of targeted interactions at every time-step, and the agents’ recurrent policies support persistent relevant information in internal states.
+
+While natural language, i.e. a finite set of discrete tokens with pre-specified human-conventionalized meanings, may seem like an intuitive protocol for inter-agent communication – one that enables human-interpretability of interactions – forcing machines to communicate among themselves in discrete tokens presents additional training challenges. Since our work focuses on machine-only multi-agent teams, we allow agents to communicate via continuous vectors (rather than discrete symbols), and via the learning process, agents have the flexibility to discover and optimize their communication protocol as per task requirements.
+
+We provide extensive empirical demonstration of the efficacy of our approach across a range of tasks, environments, and team sizes. We begin by benchmarking multi-agent communication with and without attention on a cooperative navigation task derived from the SHAPES environment (Andreas et al., 2016). We show that agents learn intuitive attention behavior across a spectrum of task difficulties. Next, we evaluate the same targeted multi-agent communication architecture on the traffic junction environment (Sukhbaatar et al., 2016), and show that agents are able to adaptively focus on ‘active’ agents in the case of varying team sizes. Finally, we demonstrate effective multi-agent communication in 3D environments on a cooperative first-person point-goal navigation task in the rich House3D environment (Wu et al., 2018).
+
+# 2 RELATED WORK
+
+Multi-agent systems fall at the intersection of game theory, distributed systems, and Artificial Intelligence in general (Shoham & Leyton-Brown, 2008), and thus have a rich and diverse literature. Our work builds on and is related to prior work in deep multi-agent reinforcement learning, the centralized training and decentralized execution paradigm, and emergent communication protocols.
+
+Multi-Agent Reinforcement Learning (MARL). Within MARL (see Busoniu et al. (2008) for a survey), our work is related to recent efforts on using recurrent neural networks to approximate agent policies (Hausknecht & Stone, 2015), algorithms stabilizing multi-agent training (Lowe et al., 2017; Foerster et al., 2018), and tasks in novel application domains such as coordination and navigation in 3D simulated environments (Peng et al., 2017; OpenAI, 2018; Jaderberg et al., 2018).
+
+Centralized Training & Decentralized Execution. Both Sukhbaatar et al. (2016) and Hoshen (2017) adopt a fully centralized framework at both training and test time – a central controller processes local observations from all agents and outputs a probability distribution over joint actions. In this setting, any controller (e.g. a fully-connected network) can be viewed as implicitly encoding communication. Sukhbaatar et al. (2016) present an efficient architecture to learn a centralized controller invariant to agent permutations – by sharing weights and averaging as in Zaheer et al. (2017). Meanwhile Hoshen (2017) proposes to replace averaging by an attentional mechanism to allow targeted interactions between agents. While closely related to our communication architecture, his work only considers fully supervised one-next-step prediction tasks, while we tackle the full reinforcement learning problem with tasks requiring planning over long time horizons.
+
+Moreover, a centralized controller quickly becomes intractable in real-world tasks with many agents and high-dimensional observation spaces (e.g. navigation in House3D (Wu et al., 2018)). To address these weaknesses, we adopt the framework of centralized learning but decentralized execution (following Foerster et al. (2016); Lowe et al. (2017)) and further relax it by allowing agents to communicate. While agents can use extra information during training, at test time, they pick actions solely based on local observations and communication messages received from other agents.
+
+Finally, we note that fully decentralized execution at test time without communication is very restrictive. It means 1) each agent must act myopically based solely on its local observation and 2) agents cannot coordinate their actions. In our setting, communication between agents offers a reasonable trade-off between allowing agents to globally coordinate while retaining tractability (since the communicated messages are much lower-dimensional than the observation space).
+
+<table><tr><td></td><td>Decentralized Execution</td><td>Targeted Communication</td><td>Multi-Stage Decisions</td><td>Reinforcement Learning</td></tr><tr><td>DIAL (Foerster et al., 2016)</td><td>Yes</td><td>No</td><td>No</td><td>Yes (Q-Learning)</td></tr><tr><td>CommNets (Sukhbaatar et al., 2016)</td><td>No</td><td>No</td><td>Yes</td><td>Yes (REINFORCE)</td></tr><tr><td>VAIN (Hoshen, 2017)</td><td>No</td><td>Yes</td><td>Yes</td><td>No (Supervised)</td></tr><tr><td>ATOC (Jiang &amp; Lu,2018)</td><td>Yes</td><td>No</td><td>No</td><td>Yes (Actor-Critic)</td></tr><tr><td>TarMAC (this paper)</td><td>Yes</td><td>Yes</td><td>Yes</td><td>Yes (Actor-Critic)</td></tr></table>
+
+Table 1: Comparison with previous work on collaborative multi-agent communication with continuous vectors.
+
+Emergent Communication Protocols. Our work is also related to recent work on learning communication protocols in a completely end-to-end manner with reinforcement learning – from perceptual input (e.g. pixels) to communication symbols (discrete or continuous) to actions (e.g. navigating in an environment). While (Foerster et al., 2016; Jorge et al., 2016; Das et al., 2017; Kottur et al., 2017; Mordatch & Abbeel, 2017; Lazaridou et al., 2017) constrain agents to communicate with discrete symbols with the explicit goal to study emergence of language, our work operates in the paradigm of learning a continuous communication protocol in order to solve a downstream task (Sukhbaatar et al., 2016; Hoshen, 2017; Jiang & Lu, 2018). While (Jiang & Lu, 2018) also operate in a decentralized execution setting and use an attentional communication mechanism, their setup is significantly different from ours as they use attention to decide when to communicate, not who to communicate with (‘who’ depends on a hand-tuned neighborhood parameter in their work). Table 1 summarizes the main axes of comparison between our work and previous efforts in this exciting space.
+
+# 3 TECHNICAL BACKGROUND
+
+Decentralized Partially Observable Markov Decision Processes (Dec-POMDPs). A DecPOMDP is a cooperative multi-agent extension of a partially observable Markov decision process (Oliehoek (2012)). For $N$ agents, it is defined by a set of states $S$ describing possible configurations of all agents, a global reward function $R$ , a transition probability function $T$ , and for each agent $i \in { 1 , . . . , N }$ a set of allowed actions $A _ { i }$ , a set of possible observations $\Omega _ { i }$ and an observation function $O _ { i }$ . Operationally, at each time step every agent picks an action $a _ { i }$ based on its local observation $\omega _ { i }$ following its own stochastic policy $\pi _ { \boldsymbol { \theta } _ { i } } ( a _ { i } | \omega _ { i } )$ . The system randomly transitions to the next state $s ^ { \prime }$ given the current state and joint action $T ( s ^ { \prime } | s , a _ { 1 } , . . . , a _ { N } )$ . The agent team receives a global reward $r = R ( s , a _ { 1 } , . . . , a _ { N } )$ while each agent receives a local observation of the new state ř $O _ { i } ( \omega _ { i } | s ^ { \prime } )$ . gents aim to maximize the total expected return $\begin{array} { r } { J = \sum _ { t = 0 } ^ { T } \gamma ^ { t } r _ { t } } \end{array}$ where $\gamma$ is a discount factor and $T$
+
+Actor-Critic Algorithms. Policy gradient methods directly adjust the parameters $\theta$ of the policy in order to maximize the objective $\begin{array} { r } { \dot { J ( \theta ) } = \mathbb { E } _ { s \sim p _ { \pi } , a \sim \pi _ { \theta } ( s ) } \left[ \dot { R ( s , a ) } \right] } \end{array}$ by taking steps in the direction of $\nabla J ( \theta )$ . We can write the gradient with respect to the policy parameters as
+
+$$
+\nabla _ { \theta } J ( \theta ) = \mathbb { E } _ { s \sim p _ { \pi } , a \sim \pi _ { \theta } ( s ) } \left[ \nabla _ { \theta } \log \pi _ { \theta } ( a | s ) Q _ { \pi } ( s , a ) \right] ,
+$$
+
+where $Q _ { \pi } ( s , a )$ is called the action-value, it is the expected remaining discounted reward if we take action $a$ in state $s$ and follow policy $\pi$ thereafter. Actor-Critic algorithms learn an approximation of the unknown true action-value function $\hat { Q } ( s , a )$ by e.g. temporal-difference learning (Sutton & Barto, 1998). This $\hat { Q } ( s , a )$ is called the Critic while the policy $\pi _ { \theta }$ is called the Actor.
+
+Multi-Agent Actor-Critic. Lowe et al. (2017) propose a multi-agent Actor-Critic algorithm adapted to centralized learning and decentralized execution. Each agent learns its own individual policy $\pi _ { \theta _ { i } } ( a _ { i } | \omega _ { i } )$ conditioned on local observation $\omega _ { i }$ , using a centralized Critic which estimates the joint action-value $\hat { Q } ( s , a _ { 1 } , . . . , a _ { N } )$ .
+
+# 4 TARMAC: TARGETED MULTI-AGENT COMMUNICATION
+
+We now describe our multi-agent communication architecture in detail. Recall that we have $N$ agents with policies $\left\{ \pi _ { 1 } , . . . , \pi _ { N } \right\}$ , respectively parameterized by $\big \{ \theta _ { 1 } , . . . , \theta _ { N } \big \}$ , jointly performing a cooperative task. At every timestep $t$ , the ith agent for all $i \in \{ 1 , . . . , N \}$ sees a local observation $\omega _ { i } ^ { t }$ , and must select a discrete environment action $\bar { \boldsymbol { a } } _ { i } ^ { t } \sim \pi _ { \boldsymbol { \theta } _ { i } }$ and a continuous communication message $m _ { i } ^ { t }$ , received by other agents at the next timestep, in order to maximize global reward $r _ { t } \sim R$ . Since no agent has access to the underlying state of the environment $s _ { t }$ , there is incentive in communicating with each other and being mutually helpful to do better as a team.
+
+![](images/bc395e5a5aab975be313e2a5d3bd2a0e1cdee750a7a411855df61900ec279d8a.jpg)  
+Figure 1: Overview of our multi-agent architecture with targeted communication. Left: At every timestep, each agent policy gets a local observation $\boldsymbol { \omega } _ { i } ^ { t }$ and aggregated message $c _ { i } ^ { t }$ as input, and predicts an environment action $a _ { i } ^ { \overline { { t } } }$ and a targeted communication message $m _ { i } ^ { \bar { t } }$ . Right: Targeted communication between agents is implemented as a signature-based soft attention mechanism. Each agent broadcasts a message $m _ { i } ^ { t }$ consisting of a signature $k _ { i } ^ { t }$ , which can be used to encode agent-specific information and a value $\boldsymbol { v } _ { i } ^ { t }$ , which contains the actual message. At the next timestep, each receiving agent gets as input a convex combination of message values, where the attention weights are obtained by a dot product between sender’s signature $k _ { i } ^ { t }$ and a query vector $\boldsymbol q _ { j } ^ { t + 1 }$ predicted from the receiver’s hidden state.
+
+Policies and Decentralized Execution. Each agent is essentially modeled as a Dec-POMDP augmented with communication. Each agent’s policy $\pi _ { \boldsymbol { \theta } _ { i } }$ is implemented as a 1-layer Gated Recurrent Unit (Cho et al., 2014). At every timestep, the local observation $\omega _ { i } ^ { t }$ and a vector $c _ { i } ^ { t }$ aggregating messages sent by all agents at the previous timestep (described in more detail below) are used to update the hidden state $h _ { i } ^ { t }$ of the GRU, which encodes the entire message-action-observation history up to time $t$ . From this internal state representation, the agent’s policy $\pi _ { \theta _ { i } } \left( a _ { i } ^ { t } | h _ { i } ^ { t } \right)$ predicts a categorical distribution over the space of actions, and another output head produces an outgoing message vector $m _ { i } ^ { t }$ . Note that for all our experiments, agents are symmetric and policies are instantiated from the same set of shared parameters; i.e. $\theta _ { 1 } = \ldots = \theta _ { N }$ . This considerably speeds up learning.
+
+Centralized Critic. Following prior work (Lowe et al., 2017; Foerster et al., 2018), we operate under the centralized learning and decentralized execution paradigm wherein during training, a centralized critic guides the optimization of individual agent policies. The centralized Critic takes as input predicted actions $\{ a _ { 1 } ^ { \bar { t } } , . . . , a _ { N } ^ { t } \}$ and internal state representations $\{ h _ { 1 } ^ { t } , . . . , h _ { N } ^ { t } \}$ from all agents to estimate the joint action-value $\hat { Q } _ { t }$ at every timestep. The centralized Critic is learned by temporal difference (Sutton $\&$ Barto, 1998) and the gradient of the expected return $J ( \theta _ { i } ) = \mathbb { E } [ R ]$ with respect to policy parameters is approximated by:
+
+$$
+\nabla _ { \theta _ { i } } J ( \theta _ { i } ) = \mathbb { E } \left[ \nabla _ { \theta _ { i } } \log \pi _ { \theta _ { i } } ( a _ { i } ^ { t } | h _ { i } ^ { t } ) \ \hat { Q } _ { t } ( h _ { 1 } ^ { t } , . . . , h _ { N } ^ { t } , a _ { t } ^ { 1 } , . . . , a _ { t } ^ { N } ) \right] .
+$$
+
+Note that compared to an individual critic $\hat { Q } _ { i } ( h _ { i } ^ { t } , a _ { i } ^ { t } )$ for each agent, having a centralized critic leads to considerably lower variance in policy gradient estimates since it takes into account actions from all agents. At test time, the critic is not needed anymore and policy execution is fully decentralized.
+
+Targeted, Multi-Stage Communication. Establishing complex collaboration strategies requires targeted communication i.e. the ability to send specific messages to specific agents, as well as multi
+
+stage communication i.e. multiple rounds of back-and-forth interactions between agents. We use a signature-based soft-attention mechanism in our communication structure to enable targeting. Each message $m _ { i } ^ { t }$ consists of 2 parts – a signature $k _ { i } ^ { t } \in \mathbb { R } ^ { d _ { k } }$ to target recipients, and a value $\mathcal { \mathbf { v } } _ { i } ^ { t } \in \mathbb { \breve { R } } ^ { d _ { v } }$ :
+
+$$
+m _ { i } ^ { t } = \big [ \begin{array} { c c } { { \frac { \mathrm { s i g n a t u r e } } { k _ { i } ^ { t } } } } & { { } } \\ { { } } & { { \frac { v _ { i } ^ { t } } { \mathrm { v a l u e } } } } \end{array} \big ] .
+$$
+
+At the receiving end, each agent (indexed by $j$ ) predicts a query vector $q _ { j } ^ { t + 1 } \in \mathbb { R } ^ { d _ { k } }$ from its hidden state ? $h _ { j } ^ { t + 1 }$ and uses it to compute a dot product with signatures of all $N$ messages. This is scaled by $1 / \sqrt { d _ { k } }$ followed by a softmax to obtain attention weight $\alpha _ { j i }$ for each message value vector:
+
+$$
+\alpha _ { j } = \mathrm { s o f t m a x } \left[ \frac { { q _ { j } ^ { t + 1 } } ^ { T } k _ { 1 } ^ { t } } { \sqrt { d _ { k } } } \dots \frac { { q _ { j } ^ { t + 1 } } ^ { T } k _ { i } ^ { t } } { \hdots \hdots \hdots } \hdots \frac { { q _ { j } ^ { t + 1 } } ^ { T } k _ { N } ^ { t } } { \sqrt { d _ { k } } } \right]
+$$
+
+$$
+c _ { j } ^ { t + 1 } = \sum _ { i = 1 } ^ { N } \alpha _ { j i } v _ { i } ^ { t } .
+$$
+
+Note that equation 2 also includes $\alpha _ { i i }$ corresponding to the ability to self-attend (Vaswani et al., 2017), which we empirically found to improve performance, especially in situations when an agent has found the goal in a coordinated navigation task and all it is required to do is stay at the goal, so others benefit from attending to this agent’s message but return communication is not needed.
+
+For multiple stages of communication, aggregated message vector $c _ { j } ^ { t + 1 }$ and internal state $h _ { j } ^ { t }$ are first used to predict the next internal state ${ h ^ { \prime } } _ { j } ^ { t }$ taking into account a first round of communication:
+
+$$
+{ h ^ { \prime } } _ { j } ^ { t } = \operatorname { t a n h } ( W _ { h  h ^ { \prime } } [ \ c _ { j } ^ { t + 1 } \ \parallel \ h _ { j } ^ { t } \ ] ) .
+$$
+
+Next, ${ h ^ { \prime } } _ { j } ^ { t }$ is used to predict signature, query, value followed by repeating Eqns 1-4 for multiple rounds until we get a final aggregated message vector $c _ { j } ^ { t + 1 }$ to be used as input at the next timestep.
+
+# 5 EXPERIMENTS
+
+We evaluate our targeted multi-agent communication architecture on a variety of tasks and environments. All our models were trained with a batched synchronous version of the multi-agent ActorCritic described above, using RMSProp with a learning rate of $7 \times 1 0 ^ { - 4 }$ and $\alpha = 0 . 9 9$ , batch size 16, discount factor $\gamma = 0 . 9 9$ and entropy regularization coefficient 0.01 for agent policies. All our agent policies are instantiated from the same set of shared parameters; i.e. $\theta _ { 1 } = \ldots = \theta _ { N }$ . Each agent’s GRU hidden state is 128-d, message signature/query is 16-d, and message value is 32-d (unless specified otherwise). All results are averaged over 5 independent runs with different seeds.
+
+# 5.1 SHAPES
+
+The SHAPES dataset was introduced by Andreas et al. $\left( 2 0 1 6 \right)$ , and originally created for testing compositional visual reasoning for the task of visual question answering. It consists of synthetic images of 2D colored shapes arranged in a grid ( $3 \times 3$ cells in the original dataset) along with corresponding question-answer pairs. There are 3 shapes (circle, square, triangle), 3 colors (red, green, blue), and 2 sizes (small, big) in total (see Figure 2).
+
+We convert each image from SHAPES into an active environment where agents can now be spawned at different regions of the image, observe a $5 \times 5$ local patch around them and their coordinates, and take actions to move around – tup, down, left, right, stayu. Each agent is tasked with navigating to a specified goal state in the environment – t‘red’, ‘blue square’, ‘small green circle’, etc. $\} -$ and the reward for each agent at every timestep is based on team performance i.e. $\begin{array} { r } { r _ { t } = \frac { \# \mathrm { a g e n t s ~ o n ~ g o a l } } { \# \mathrm { a g e n t s } } } \end{array}$
+
+![](images/4576e03e27c2832c081c391c28c88faecf612a0969853f4bbfb04e6b85fbf912.jpg)  
+(a) 4 agents have to find rred, red, green, blues respectively. $t = 1$ : inital spawn locations; $t = 2$ : 4 was on red at $t = 1$ so 1 and 2 attend to messages from 4 since they have to find red. 3 has found its goal (green) and is self-attending; $t = 6$ : 4 attends to messages from 2 as 2 is on $4$ ’s target – blue; $t = 8$ : 1 finds red, so 1 and 2 shift attention to 1; $t = 2 1$ : all agents are at their respective goal locations and primarily self-attending.
+
+![](images/a5b777d28b1efa0d622687ea099c17e88ae1f39400c36192a6b9de31d75798b7.jpg)
+
+(b) 8 agents have to find red on a large $1 0 0 \times 1 0 0$ environment. $t = 7$ : Agent 2 finds red and signals all other agents; $t = 7$ to $t = 1 5 0$ : All agents make their way to 2’s location and eventually converge around red.
+
+Figure 2: Visualizations of learned targeted communication in SHAPES. Figure best viewed in color.   
+
+<table><tr><td></td><td></td><td></td><td>30 × 30,4agents,find[red]50 × 50,4agents,find[red]50 × 50,4agents,find[red,red,green,blue]</td></tr><tr><td>No communication</td><td>95.3±2.8%</td><td>83.6±3.3%</td><td>69.1±4.6%</td></tr><tr><td>No attention</td><td>99.7±0.8%</td><td>89.5±1.4%</td><td>82.4±2.1%</td></tr><tr><td>TarMAC</td><td>99.8±0.9%</td><td>89.5±1.7%</td><td>85.8±2.5%</td></tr></table>
+
+Table 2: Success rates on 3 different settings of cooperative navigation in the SHAPES environment.
+
+Having a symmetric, team-based reward incentivizes agents to cooperate with each other in finding each agent’s goal. For example, as shown in Figure 2a, if agent 2’s goal is to find red and agent 4’s goal is to find blue, it is in agent 4’s interest to let agent 2 know if it passes by red $( t = 2$ ) during its exploration / quest for blue and vice versa $( t = 6$ ). SHAPES serves as a flexible testbed for carefully controlling and analyzing the effect of changing the size of the environment, no. of agents, goal configurations, etc. Figure 2 visualizes learned protocols from two different configurations, and Table 2 reports quantitative evaluation for three different configurations. Benefits of communication and attention increase with task complexity ( $3 0 \times 3 0 \to 5 0 \times 5 0$ & findrreds findrred,red,green,blues).
+
+How does targeting work in the communication learnt by TarMAC? Recall that each agent predicts a signature and value vector as part of the message it sends, and a query vector to attend to incoming messages. The communication is targeted because the attention probabilities are a function of both the sender’s signature and receiver’s query vectors. So it is not just the receiver deciding how much of each message to listen to. The sender also sends out signatures that affects how much of each message is sent to each receiver. The sender’s signature could encode parts of its observation most relevant to other agents’ goals (for example, it would be futile to convey coordinates in the signature), and the message value could contain the agent’s own location. For example, in Figure 2a, at $t = 6$ , we see that when agent 2 passes by blue, agent 4 starts attending to agent 2. Here, agent 2’s signature encodes the color it observes (which is blue), and agent 4’s query encodes its goal (which is also blue) leading to high attention probability. Agent 2’s message value encodes coordinates agent 4 has to navigate to, as can be seen at $t = 2 1$ when agent 4 reaches there.
+
+# 5.2 TRAFFIC JUNCTION
+
+<table><tr><td></td><td>Easy</td><td>Hard</td></tr><tr><td>No communication</td><td>84.9±4.3%</td><td>74.1±3.9%</td></tr><tr><td>CommNets (Sukhbaatar et al., 2016)</td><td>99.7±0.1%</td><td>78.9±3.4%</td></tr><tr><td>TarMAC 1-stage</td><td>99.9±0.1%</td><td>84.6±3.2%</td></tr><tr><td>TarMAC 2-stage</td><td>99.9±0.1%</td><td>97.1±1.6%</td></tr></table>
+
+Table 3: Success rates on traffic junction. Our targeted 2-stage communication architecture gets a success rate of $9 7 . 1 \%$ on the ‘hard’ variant of the task, significantly outperforming Sukhbaatar et al. (2016). Note that $1 \mathrm { - }$ and 2-stage refer to the number of rounds of communication between actions (Equation 4).
+
+![](images/42c7b922f493e22504b75c747cefd681495b7fc95cebf19d4767eacbe462fc43.jpg)  
+Figure 3: Success rates for 1 vs. 2-stage vs. message size on Hard. Performance does not decrease significantly even when the message vector is a single scalar, and 2 rounds of back-and-forth communication before taking an environment action leads to a significant improvement over 1-stage.
+
+![](images/484b7250cf4ef991db8bb33f64c548095baaf4a169dd981655636de939bfa65f.jpg)  
+(c) No. of cars being attended to. 1) is positively correlated with total cars, indicating that TarMAC is adaptive to dynamic team sizes, and 2) is slightly right-shifted, since it takes few steps of communication to adapt.
+
+(a) Brake probabilities at dif- (b) Attention probabilities at ferent locations on the hard different locations. Cars are traffic junction environment. most attended to in the ‘interCars tend to brake close to or nal grid’ – right after the 1st right before entering junctions. junction and before the 2nd.
+
+![](images/187ff4300ed4c435b4a7b5a33a4739e5aee142e7ad4153d00b44202b62550544.jpg)  
+Figure 4: Results on the traffic junction environment.
+
+Environment and Task. The simulated traffic junction environments from Sukhbaatar et al. (2016) consist of cars moving along pre-assigned, potentially intersecting routes on one or more road junctions. The total number of cars is fixed at $N _ { \mathrm { m a x } }$ and at every timestep, new cars get added to the environment with probability $p _ { \mathrm { a r r i v e } }$ . Once a car completes its route, it becomes available to be sampled and added back to the environment with a different route assignment. Each car has a limited visibility of a $3 \times 3$ region around it, but is free to communicate with all other cars. The action space for each car at every timestep is gas and brake, and the reward consists of a linear time penalty $- 0 . 0 1 \tau$ , where $\tau$ is the number of timesteps since car has been active, and a collision penalty $r _ { \mathrm { c o l l i s i o n } } = - 1 0$ .
+
+Quantitative Results. We compare our approach with CommNets (Sukhbaatar et al., 2016) on the easy and hard difficulties of the traffic junction environment. The easy task has one junction of two one-way roads on a $7 \times 7$ grid with $N _ { \mathrm { m a x } } ~ = ~ 5$ and $p _ { \mathrm { a r r i v e } } ~ = ~ 0 . 3 0$ , while the hard task has four connected junctions of two-way roads on a $1 8 \times 1 8$ grid with $N _ { \mathrm { m a x } } = 2 0$ and $p _ { \mathrm { a r r i v e } } = 0 . 0 5$ .
+
+See Figure 4a, 4b for an example of the four two-way junctions in the hard task. As shown in Table 3, a no communication baseline has success rates of $8 4 . 9 \%$ and $7 4 . 1 \%$ on easy and hard respectively. On easy, both CommNets and TarMAC get close to $1 0 0 \%$ . On hard, TarMAC with 1-stage communication significantly outperforms CommNets with a success rate of $8 4 . 6 \%$ , while 2- stage further improves on this at $9 7 . 1 \%$ , which is an $\sim 1 8 \%$ absolute improvement over CommNets.
+
+Model Interpretation. Interpreting the learned policies, Figure 4a shows braking probabilities at different locations: cars tend to brake close to or right before entering traffic junctions, which is reasonable since junctions have the highest chances for collisions.
+
+Turning our attention to attention probabilities (Figure $4 \mathrm { b }$ ), we can see that cars are most-attended to when in the ‘internal grid’ – right after crossing the 1st junction and before hitting the 2nd junction. These attention probabilities are intuitive: cars learn to attentively attend to specific sensitive locations with the most relevant local observations to avoid collisions.
+
+Finally, Figure 4c compares total number of cars in the environment vs. number of cars being attended to with probability $> 0 . 1$ at any time. Interestingly, these are (loosely) positively correlated, with Spearman’s $\sigma = 0 . 4 9$ , which shows that TarMAC is able to adapt to variable number of agents. Crucially, agents learn this dynamic targeting behavior purely from task rewards with no handcoding! Note that the right shift between the two curves is expected, as it takes a few timesteps of communication for team size changes to propagate. At a relative time shift of 3, the Spearman’s rank correlation between the two curves goes up to 0.53.
+
+Message size vs. multi-stage communication. We study performance of TarMAC with varying message value size and number of rounds of communication on the ‘hard’ variant of the traffic junction task. As can be seen in Figure 3, multiple rounds of communication leads to significantly higher performance than simply increasing message size, demonstrating the advantage of multistage communication. In fact, decreasing message size to a single scalar performs almost as well as 64-d, perhaps because even a single real number can be sufficiently partitioned to cover the space of meanings/messages that need to be conveyed for this task.
+
+# 5.3 HOUSE3D
+
+Finally, we benchmark TarMAC on a cooperative point-goal navigation task in House3D (Wu et al., 2018). House3D provides a rich and diverse set of publicly-available2 3D indoor environments, wherein agents do not have access to the top-down map and must navigate purely from first-person vision. Similar to SHAPES, the agents are tasked with finding a specified goal (such as ‘fireplace’), spawned at random locations in the environment and allowed to communicate with each other and move around. Each agent gets a shaped reward based on progress towards the specified target. An episode is successful if all agents end within $0 . 5 \mathrm { m }$ of the target object in 50 navigation steps.
+
+Table 4 shows success rates on a find[fireplace] task in House3D. A no-communication navigation policy trained with the same reward structure gets a success rate of $6 2 . 1 \%$ . Mean-pooled communication (no attention) performs slightly better with a success rate of $6 4 . 3 \%$ , and TarMAC achieves the best success rate at $6 8 . 9 \%$ . Figure 5 visualizes predicted navigation trajectories of 4 agents. Note that the communication vectors are significantly more compact (32-d) than the high-dimensional observation space, making our approach particularly attractive for scaling to large teams.
+
+<table><tr><td></td><td>Success rate</td></tr><tr><td>No communication</td><td>62.1±5.3%</td></tr><tr><td>No attention</td><td>64.3±2.3%</td></tr><tr><td>TarMAC</td><td>68.9±1.1%</td></tr></table>
+
+Table 4: Success rates on a 4-agent cooperative find[fireplace] navigation task in House3D.
+
+# 6 CONCLUSIONS AND FUTURE WORK
+
+We introduced TarMAC, an architecture for multi-agent reinforcement learning which allows targeted interactions between agents and multiple stages of collaborative reasoning at every timestep.
+
+![](images/f196b2ffbc786f91e8cbfc725e81b5f6b5171e6de9fdeaaa94ccbb8e898f5059.jpg)  
+Figure 5: Agents navigating to the fireplace in House3D (marked in yellow). Note in particular that agent 4 is spawned facing away from it. It communicates with others, turns to face the fireplace, and moves towards it.
+
+Evaluation on three diverse environments show that our model is able to learn intuitive attention behavior and improves performance, with downstream task-specific team reward as sole supervision.
+
+While multi-agent navigation experiments in House3D show promising performance, we aim to exhaustively benchmark TarMAC on more challenging 3D navigation tasks because we believe this is where decentralized targeted communication can have the most impact – as it allows scaling to a large number of agents with large observation spaces. Given that the 3D navigation problem is hard in and of itself, it would be particularly interesting to investigate combinations with recent advances orthogonal to our approach (e.g. spatial memory, planning networks) with the TarMAC framework.
+
+# REFERENCES
+
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural Module Networks. In CVPR, 2016. 2, 5
+
+L. Busoniu, R. Babuska, and B. De Schutter. A Comprehensive Survey of Multiagent Reinforcement Learning. Trans. Sys. Man Cyber Part C, 2008. 2
+
+Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In EMNLP, 2014. 4
+
+Abhishek Das, Satwik Kottur, José M.F. Moura, Stefan Lee, and Dhruv Batra. Learning Cooperative Visual Dialog Agents with Deep Reinforcement Learning. In ICCV, 2017. 3
+
+Jakob Foerster, Yannis M Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In NIPS, 2016. 1, 2, 3
+
+Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In AAAI, 2018. 2, 4
+
+Matthew Hausknecht and Peter Stone. Deep Recurrent Q-Learning for Partially Observable MDPs. In AAAI, 2015. 2
+
+Yedid Hoshen. VAIN: Attentional multi-agent predictive modeling. In NIPS. 2017. 2, 3
+
+Max Jaderberg, Wojciech M. Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C. Rabinowitz, Ari S. Morcos, Avraham Ruderman, Nicolas Sonnerat, Tim Green, Louise Deason, Joel Z. Leibo, David Silver, Demis Hassabis, Koray Kavukcuoglu, and Thore Graepel. Human-level performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv preprint arXiv:1807.01281, 2018. 2
+
+Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. CoRR, 2018. 3
+
+Emilio Jorge, Mikael Kågebäck, and Emil Gustavsson. Learning to play guess who? and inventing a grounded language as a consequence. In NIPS workshop on Deep Reinforcement Learning, 2016. 3
+
+Satwik Kottur, José MF Moura, Stefan Lee, and Dhruv Batra. Natural language does not emerge ‘naturally’ in multi-agent dialog. In EMNLP, 2017. 3
+
+Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In ICLR, 2017. 3
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actorcritic for mixed cooperative-competitive environments. In NIPS, 2017. 2, 3, 4
+
+Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. arXiv preprint arXiv:1703.04908, 2017. 3
+
+Frans A. Oliehoek. Decentralized POMDPs. In Reinforcement Learning: State of the Art. Springer Berlin Heidelberg, 2012. 3
+
+OpenAI. OpenAI Five. https://blog.openai.com/openai-five/, 2018. 2
+
+Peng Peng, Quan Yuan, Ying Wen, Yaodong Yang, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent bidirectionally-coordinated nets for learning to play starcraft combat games. arXiv preprint arXiv:1703.10069, 2017. 2
+
+Yoav Shoham and Kevin Leyton-Brown. Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. Cambridge University Press, 2008. 2
+
+Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Learning multiagent communication with backpropagation. In NIPS, 2016. 1, 2, 3, 7
+
+Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, 1998. 3, 4
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS, 2017. 5
+
+Yi Wu, Yuxin Wu, Georgia Gkioxari, and Yuandong Tian. Building Generalizable Agents With a Realistic And Rich 3D Environment. arXiv preprint arXiv:1801.02209, 2018. 2, 8
+
+Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In NIPS, 2017. 2

parse/train/H1e572A5tQ/H1e572A5tQ_content_list.json

@@ -0,0 +1,1239 @@
+[
+    {
+        "type": "text",
+        "text": "TARMAC: TARGETED MULTI-AGENT COMMUNICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            736,
+            118
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            143,
+            326,
+            156
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Paper under double-blind review ",
+        "bbox": [
+            184,
+            157,
+            398,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            207,
+            544,
+            222
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We explore a collaborative multi-agent reinforcement learning setting where a team of agents attempts to solve cooperative tasks in partially-observable environments. In this scenario, learning an effective communication protocol is key. We propose a communication architecture that allows for targeted communication, where agents learn both what messages to send and who to send them to, solely from downstream task-specific reward without any communication supervision. ",
+        "bbox": [
+            233,
+            243,
+            764,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we introduce a multi-stage communication approach where the agents co-ordinate via multiple rounds of communication before taking actions in the environment. We evaluate our approach on a diverse set of cooperative multi-agent tasks, of varying difficulties, with varying number of agents, in a variety of environments ranging from 2D grid layouts of shapes and simulated traffic junctions to complex 3D indoor environments. We demonstrate the benefits of targeted as well as multi-stage communication. Moreover, we show that the targeted communication strategies learned by agents are both interpretable and intuitive. ",
+        "bbox": [
+            233,
+            328,
+            764,
+            438
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            336,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Effective communication is a key ability for collaborative multi-agents systems. Indeed, intelligent agents (humans or artificial) in real-world scenarios can significantly benefit from exchanging information that enables them to coordinate, strategize, and utilize their combined sensory experiences to act in the physical world. The ability to communicate has wide-ranging applications for artificial agents – from multi-player gameplay in simulated games (e.g. DoTA, Quake, StarCraft) or physical worlds (e.g. robot soccer), to networks of self-driving cars communicating with each other to achieve safe and swift transport, to teams of robots on search-and-rescue missions deployed in hostile and fast-evolving environments. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A salient property of human communication is the ability to hold targeted interactions. Rather than the ‘one-size-fits-all’ approach of broadcasting messages to all participating agents, as has been previously explored (Sukhbaatar et al., 2016; Foerster et al., 2016), it can be useful to direct certain messages to specific recipients. This enables a more flexible collaboration strategy in complex environments. For example, within a team of search-and-rescue robots with a diverse set of roles and goals, a message for a fire-fighter (“smoke is coming from the kitchen”) is largely meaningless for a bomb-defuser. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we develop a collaborative multi-agent deep reinforcement learning approach that supports targeted communication. Crucially, each individual agent actively selects which other agents to send messages to. This targeted communication behavior is operationalized via a simple signaturebased soft attention mechanism: along with the message, the sender broadcasts a key which encodes properties of agents the message is intended for, and is used by receivers to gauge the relevance of the message. This communication mechanism is learned implicitly, without any attention supervision, as a result of end-to-end training using a downstream task-specific team reward. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The inductive bias provided by soft attention in the communication architecture is sufficient to enable agents to 1) communicate agent-goal-specific messages (e.g. guide fire-fighter towards fire, bomb-defuser towards bomb, etc.), 2) be adaptive to variable team sizes (e.g. the size of the local neighborhood a self-driving car can communicate with changes as it moves), and 3) be interpretable through predicted attention probabilities that allow for inspection of which agent is communicating what message and to whom. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our results however show that just using targeted communication is not enough. Complex realworld tasks might require large populations of agents to go through multiple stages of collaborative communication and reasoning, involving large amounts of information to be persistent in memory and exchanged via high-bandwidth communication channels. To this end, our actor-critic framework combines centralized training with decentralized execution (Lowe et al., 2017), thus enabling scaling to a large number of agents. In this context, our inter-agent communication architecture supports multiple stages of targeted interactions at every time-step, and the agents’ recurrent policies support persistent relevant information in internal states. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While natural language, i.e. a finite set of discrete tokens with pre-specified human-conventionalized meanings, may seem like an intuitive protocol for inter-agent communication – one that enables human-interpretability of interactions – forcing machines to communicate among themselves in discrete tokens presents additional training challenges. Since our work focuses on machine-only multi-agent teams, we allow agents to communicate via continuous vectors (rather than discrete symbols), and via the learning process, agents have the flexibility to discover and optimize their communication protocol as per task requirements. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We provide extensive empirical demonstration of the efficacy of our approach across a range of tasks, environments, and team sizes. We begin by benchmarking multi-agent communication with and without attention on a cooperative navigation task derived from the SHAPES environment (Andreas et al., 2016). We show that agents learn intuitive attention behavior across a spectrum of task difficulties. Next, we evaluate the same targeted multi-agent communication architecture on the traffic junction environment (Sukhbaatar et al., 2016), and show that agents are able to adaptively focus on ‘active’ agents in the case of varying team sizes. Finally, we demonstrate effective multi-agent communication in 3D environments on a cooperative first-person point-goal navigation task in the rich House3D environment (Wu et al., 2018). ",
+        "bbox": [
+            174,
+            327,
+            825,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            344,
+            489
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-agent systems fall at the intersection of game theory, distributed systems, and Artificial Intelligence in general (Shoham & Leyton-Brown, 2008), and thus have a rich and diverse literature. Our work builds on and is related to prior work in deep multi-agent reinforcement learning, the centralized training and decentralized execution paradigm, and emergent communication protocols. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-Agent Reinforcement Learning (MARL). Within MARL (see Busoniu et al. (2008) for a survey), our work is related to recent efforts on using recurrent neural networks to approximate agent policies (Hausknecht & Stone, 2015), algorithms stabilizing multi-agent training (Lowe et al., 2017; Foerster et al., 2018), and tasks in novel application domains such as coordination and navigation in 3D simulated environments (Peng et al., 2017; OpenAI, 2018; Jaderberg et al., 2018). ",
+        "bbox": [
+            174,
+            568,
+            823,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Centralized Training & Decentralized Execution. Both Sukhbaatar et al. (2016) and Hoshen (2017) adopt a fully centralized framework at both training and test time – a central controller processes local observations from all agents and outputs a probability distribution over joint actions. In this setting, any controller (e.g. a fully-connected network) can be viewed as implicitly encoding communication. Sukhbaatar et al. (2016) present an efficient architecture to learn a centralized controller invariant to agent permutations – by sharing weights and averaging as in Zaheer et al. (2017). Meanwhile Hoshen (2017) proposes to replace averaging by an attentional mechanism to allow targeted interactions between agents. While closely related to our communication architecture, his work only considers fully supervised one-next-step prediction tasks, while we tackle the full reinforcement learning problem with tasks requiring planning over long time horizons. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Moreover, a centralized controller quickly becomes intractable in real-world tasks with many agents and high-dimensional observation spaces (e.g. navigation in House3D (Wu et al., 2018)). To address these weaknesses, we adopt the framework of centralized learning but decentralized execution (following Foerster et al. (2016); Lowe et al. (2017)) and further relax it by allowing agents to communicate. While agents can use extra information during training, at test time, they pick actions solely based on local observations and communication messages received from other agents. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, we note that fully decentralized execution at test time without communication is very restrictive. It means 1) each agent must act myopically based solely on its local observation and 2) agents cannot coordinate their actions. In our setting, communication between agents offers a reasonable trade-off between allowing agents to globally coordinate while retaining tractability (since the communicated messages are much lower-dimensional than the observation space). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee102ebaa7bcf39d7c1715a01c254061fd662d9f0556b3ad054de0727973c9f2.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Comparison with previous work on collaborative multi-agent communication with continuous vectors. "
+        ],
+        "table_body": "<table><tr><td></td><td>Decentralized Execution</td><td>Targeted Communication</td><td>Multi-Stage Decisions</td><td>Reinforcement Learning</td></tr><tr><td>DIAL (Foerster et al., 2016)</td><td>Yes</td><td>No</td><td>No</td><td>Yes (Q-Learning)</td></tr><tr><td>CommNets (Sukhbaatar et al., 2016)</td><td>No</td><td>No</td><td>Yes</td><td>Yes (REINFORCE)</td></tr><tr><td>VAIN (Hoshen, 2017)</td><td>No</td><td>Yes</td><td>Yes</td><td>No (Supervised)</td></tr><tr><td>ATOC (Jiang &amp; Lu,2018)</td><td>Yes</td><td>No</td><td>No</td><td>Yes (Actor-Critic)</td></tr><tr><td>TarMAC (this paper)</td><td>Yes</td><td>Yes</td><td>Yes</td><td>Yes (Actor-Critic)</td></tr></table>",
+        "bbox": [
+            176,
+            88,
+            825,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            226,
+            821,
+            253
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Emergent Communication Protocols. Our work is also related to recent work on learning communication protocols in a completely end-to-end manner with reinforcement learning – from perceptual input (e.g. pixels) to communication symbols (discrete or continuous) to actions (e.g. navigating in an environment). While (Foerster et al., 2016; Jorge et al., 2016; Das et al., 2017; Kottur et al., 2017; Mordatch & Abbeel, 2017; Lazaridou et al., 2017) constrain agents to communicate with discrete symbols with the explicit goal to study emergence of language, our work operates in the paradigm of learning a continuous communication protocol in order to solve a downstream task (Sukhbaatar et al., 2016; Hoshen, 2017; Jiang & Lu, 2018). While (Jiang & Lu, 2018) also operate in a decentralized execution setting and use an attentional communication mechanism, their setup is significantly different from ours as they use attention to decide when to communicate, not who to communicate with (‘who’ depends on a hand-tuned neighborhood parameter in their work). Table 1 summarizes the main axes of comparison between our work and previous efforts in this exciting space. ",
+        "bbox": [
+            173,
+            260,
+            825,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 TECHNICAL BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            446,
+            431,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Decentralized Partially Observable Markov Decision Processes (Dec-POMDPs). A DecPOMDP is a cooperative multi-agent extension of a partially observable Markov decision process (Oliehoek (2012)). For $N$ agents, it is defined by a set of states $S$ describing possible configurations of all agents, a global reward function $R$ , a transition probability function $T$ , and for each agent $i \\in { 1 , . . . , N }$ a set of allowed actions $A _ { i }$ , a set of possible observations $\\Omega _ { i }$ and an observation function $O _ { i }$ . Operationally, at each time step every agent picks an action $a _ { i }$ based on its local observation $\\omega _ { i }$ following its own stochastic policy $\\pi _ { \\boldsymbol { \\theta } _ { i } } ( a _ { i } | \\omega _ { i } )$ . The system randomly transitions to the next state $s ^ { \\prime }$ given the current state and joint action $T ( s ^ { \\prime } | s , a _ { 1 } , . . . , a _ { N } )$ . The agent team receives a global reward $r = R ( s , a _ { 1 } , . . . , a _ { N } )$ while each agent receives a local observation of the new state ř $O _ { i } ( \\omega _ { i } | s ^ { \\prime } )$ . gents aim to maximize the total expected return $\\begin{array} { r } { J = \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r _ { t } } \\end{array}$ where $\\gamma$ is a discount factor and $T$ ",
+        "bbox": [
+            173,
+            478,
+            825,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Actor-Critic Algorithms. Policy gradient methods directly adjust the parameters $\\theta$ of the policy in order to maximize the objective $\\begin{array} { r } { \\dot { J ( \\theta ) } = \\mathbb { E } _ { s \\sim p _ { \\pi } , a \\sim \\pi _ { \\theta } ( s ) } \\left[ \\dot { R ( s , a ) } \\right] } \\end{array}$ by taking steps in the direction of $\\nabla J ( \\theta )$ . We can write the gradient with respect to the policy parameters as ",
+        "bbox": [
+            174,
+            641,
+            825,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de5fdb19c4a64c5fe0ff9c448e53201249c0b8ba312adeed8de3ebb0be33ecc1.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J ( \\theta ) = \\mathbb { E } _ { s \\sim p _ { \\pi } , a \\sim \\pi _ { \\theta } ( s ) } \\left[ \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( a | s ) Q _ { \\pi } ( s , a ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            693,
+            671,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $Q _ { \\pi } ( s , a )$ is called the action-value, it is the expected remaining discounted reward if we take action $a$ in state $s$ and follow policy $\\pi$ thereafter. Actor-Critic algorithms learn an approximation of the unknown true action-value function $\\hat { Q } ( s , a )$ by e.g. temporal-difference learning (Sutton & Barto, 1998). This $\\hat { Q } ( s , a )$ is called the Critic while the policy $\\pi _ { \\theta }$ is called the Actor. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-Agent Actor-Critic. Lowe et al. (2017) propose a multi-agent Actor-Critic algorithm adapted to centralized learning and decentralized execution. Each agent learns its own individual policy $\\pi _ { \\theta _ { i } } ( a _ { i } | \\omega _ { i } )$ conditioned on local observation $\\omega _ { i }$ , using a centralized Critic which estimates the joint action-value $\\hat { Q } ( s , a _ { 1 } , . . . , a _ { N } )$ . ",
+        "bbox": [
+            174,
+            785,
+            825,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 TARMAC: TARGETED MULTI-AGENT COMMUNICATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            863,
+            673,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now describe our multi-agent communication architecture in detail. Recall that we have $N$ agents with policies $\\left\\{ \\pi _ { 1 } , . . . , \\pi _ { N } \\right\\}$ , respectively parameterized by $\\big \\{ \\theta _ { 1 } , . . . , \\theta _ { N } \\big \\}$ , jointly performing a cooperative task. At every timestep $t$ , the ith agent for all $i \\in \\{ 1 , . . . , N \\}$ sees a local observation $\\omega _ { i } ^ { t }$ , and must select a discrete environment action $\\bar { \\boldsymbol { a } } _ { i } ^ { t } \\sim \\pi _ { \\boldsymbol { \\theta } _ { i } }$ and a continuous communication message $m _ { i } ^ { t }$ , received by other agents at the next timestep, in order to maximize global reward $r _ { t } \\sim R$ . Since no agent has access to the underlying state of the environment $s _ { t }$ , there is incentive in communicating with each other and being mutually helpful to do better as a team. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc395e5a5aab975be313e2a5d3bd2a0e1cdee750a7a411855df61900ec279d8a.jpg",
+        "image_caption": [
+            "Figure 1: Overview of our multi-agent architecture with targeted communication. Left: At every timestep, each agent policy gets a local observation $\\boldsymbol { \\omega } _ { i } ^ { t }$ and aggregated message $c _ { i } ^ { t }$ as input, and predicts an environment action $a _ { i } ^ { \\overline { { t } } }$ and a targeted communication message $m _ { i } ^ { \\bar { t } }$ . Right: Targeted communication between agents is implemented as a signature-based soft attention mechanism. Each agent broadcasts a message $m _ { i } ^ { t }$ consisting of a signature $k _ { i } ^ { t }$ , which can be used to encode agent-specific information and a value $\\boldsymbol { v } _ { i } ^ { t }$ , which contains the actual message. At the next timestep, each receiving agent gets as input a convex combination of message values, where the attention weights are obtained by a dot product between sender’s signature $k _ { i } ^ { t }$ and a query vector $\\boldsymbol q _ { j } ^ { t + 1 }$ predicted from the receiver’s hidden state. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            102,
+            825,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            487,
+            825,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Policies and Decentralized Execution. Each agent is essentially modeled as a Dec-POMDP augmented with communication. Each agent’s policy $\\pi _ { \\boldsymbol { \\theta } _ { i } }$ is implemented as a 1-layer Gated Recurrent Unit (Cho et al., 2014). At every timestep, the local observation $\\omega _ { i } ^ { t }$ and a vector $c _ { i } ^ { t }$ aggregating messages sent by all agents at the previous timestep (described in more detail below) are used to update the hidden state $h _ { i } ^ { t }$ of the GRU, which encodes the entire message-action-observation history up to time $t$ . From this internal state representation, the agent’s policy $\\pi _ { \\theta _ { i } } \\left( a _ { i } ^ { t } | h _ { i } ^ { t } \\right)$ predicts a categorical distribution over the space of actions, and another output head produces an outgoing message vector $m _ { i } ^ { t }$ . Note that for all our experiments, agents are symmetric and policies are instantiated from the same set of shared parameters; i.e. $\\theta _ { 1 } = \\ldots = \\theta _ { N }$ . This considerably speeds up learning. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Centralized Critic. Following prior work (Lowe et al., 2017; Foerster et al., 2018), we operate under the centralized learning and decentralized execution paradigm wherein during training, a centralized critic guides the optimization of individual agent policies. The centralized Critic takes as input predicted actions $\\{ a _ { 1 } ^ { \\bar { t } } , . . . , a _ { N } ^ { t } \\}$ and internal state representations $\\{ h _ { 1 } ^ { t } , . . . , h _ { N } ^ { t } \\}$ from all agents to estimate the joint action-value $\\hat { Q } _ { t }$ at every timestep. The centralized Critic is learned by temporal difference (Sutton $\\&$ Barto, 1998) and the gradient of the expected return $J ( \\theta _ { i } ) = \\mathbb { E } [ R ]$ with respect to policy parameters is approximated by: ",
+        "bbox": [
+            173,
+            695,
+            825,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab6f8d2e2d86e3e9aa799a236a0121356d089d609b85cc2d5e2aef89c816aab1.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { i } } J ( \\theta _ { i } ) = \\mathbb { E } \\left[ \\nabla _ { \\theta _ { i } } \\log \\pi _ { \\theta _ { i } } ( a _ { i } ^ { t } | h _ { i } ^ { t } ) \\ \\hat { Q } _ { t } ( h _ { 1 } ^ { t } , . . . , h _ { N } ^ { t } , a _ { t } ^ { 1 } , . . . , a _ { t } ^ { N } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            803,
+            709,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that compared to an individual critic $\\hat { Q } _ { i } ( h _ { i } ^ { t } , a _ { i } ^ { t } )$ for each agent, having a centralized critic leads to considerably lower variance in policy gradient estimates since it takes into account actions from all agents. At test time, the critic is not needed anymore and policy execution is fully decentralized. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Targeted, Multi-Stage Communication. Establishing complex collaboration strategies requires targeted communication i.e. the ability to send specific messages to specific agents, as well as multi",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "stage communication i.e. multiple rounds of back-and-forth interactions between agents. We use a signature-based soft-attention mechanism in our communication structure to enable targeting. Each message $m _ { i } ^ { t }$ consists of 2 parts – a signature $k _ { i } ^ { t } \\in \\mathbb { R } ^ { d _ { k } }$ to target recipients, and a value $\\mathcal { \\mathbf { v } } _ { i } ^ { t } \\in \\mathbb { \\breve { R } } ^ { d _ { v } }$ : ",
+        "bbox": [
+            174,
+            103,
+            825,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92c7b9058b518a592b94aacedd5daaa75e00070f76cb70fd51a7f6dfa684254b.jpg",
+        "text": "$$\nm _ { i } ^ { t } = \\big [ \\begin{array} { c c } { { \\frac { \\mathrm { s i g n a t u r e } } { k _ { i } ^ { t } } } } & { { } } \\\\ { { } } & { { \\frac { v _ { i } ^ { t } } { \\mathrm { v a l u e } } } } \\end{array} \\big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            154,
+            586,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At the receiving end, each agent (indexed by $j$ ) predicts a query vector $q _ { j } ^ { t + 1 } \\in \\mathbb { R } ^ { d _ { k } }$ from its hidden state ? $h _ { j } ^ { t + 1 }$ and uses it to compute a dot product with signatures of all $N$ messages. This is scaled by $1 / \\sqrt { d _ { k } }$ followed by a softmax to obtain attention weight $\\alpha _ { j i }$ for each message value vector: ",
+        "bbox": [
+            174,
+            209,
+            825,
+            260
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7987936737ae30dbf9c99fcb85196cb1b4457397ea26f7a9d987631346340505.jpg",
+        "text": "$$\n\\alpha _ { j } = \\mathrm { s o f t m a x } \\left[ \\frac { { q _ { j } ^ { t + 1 } } ^ { T } k _ { 1 } ^ { t } } { \\sqrt { d _ { k } } } \\dots \\frac { { q _ { j } ^ { t + 1 } } ^ { T } k _ { i } ^ { t } } { \\hdots \\hdots \\hdots } \\hdots \\frac { { q _ { j } ^ { t + 1 } } ^ { T } k _ { N } ^ { t } } { \\sqrt { d _ { k } } } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            265,
+            655,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7c4bd7d20e5d972a68ec125c84a74b25b5a1cd304169b853b3f604d3d179888.jpg",
+        "text": "$$\nc _ { j } ^ { t + 1 } = \\sum _ { i = 1 } ^ { N } \\alpha _ { j i } v _ { i } ^ { t } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            338,
+            558,
+            380
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that equation 2 also includes $\\alpha _ { i i }$ corresponding to the ability to self-attend (Vaswani et al., 2017), which we empirically found to improve performance, especially in situations when an agent has found the goal in a coordinated navigation task and all it is required to do is stay at the goal, so others benefit from attending to this agent’s message but return communication is not needed. ",
+        "bbox": [
+            176,
+            388,
+            825,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For multiple stages of communication, aggregated message vector $c _ { j } ^ { t + 1 }$ and internal state $h _ { j } ^ { t }$ are first used to predict the next internal state ${ h ^ { \\prime } } _ { j } ^ { t }$ taking into account a first round of communication: ",
+        "bbox": [
+            174,
+            450,
+            823,
+            486
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf0d2903fd4bcd83577bb4a3f5636d249ed770428e819ab3d78e036ae9841867.jpg",
+        "text": "$$\n{ h ^ { \\prime } } _ { j } ^ { t } = \\operatorname { t a n h } ( W _ { h  h ^ { \\prime } } [ \\ c _ { j } ^ { t + 1 } \\ \\parallel \\ h _ { j } ^ { t } \\ ] ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            493,
+            619,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, ${ h ^ { \\prime } } _ { j } ^ { t }$ is used to predict signature, query, value followed by repeating Eqns 1-4 for multiple rounds until we get a final aggregated message vector $c _ { j } ^ { t + 1 }$ to be used as input at the next timestep. ",
+        "bbox": [
+            173,
+            523,
+            826,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            328,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our targeted multi-agent communication architecture on a variety of tasks and environments. All our models were trained with a batched synchronous version of the multi-agent ActorCritic described above, using RMSProp with a learning rate of $7 \\times 1 0 ^ { - 4 }$ and $\\alpha = 0 . 9 9$ , batch size 16, discount factor $\\gamma = 0 . 9 9$ and entropy regularization coefficient 0.01 for agent policies. All our agent policies are instantiated from the same set of shared parameters; i.e. $\\theta _ { 1 } = \\ldots = \\theta _ { N }$ . Each agent’s GRU hidden state is 128-d, message signature/query is 16-d, and message value is 32-d (unless specified otherwise). All results are averaged over 5 independent runs with different seeds. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 SHAPES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            722,
+            281,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The SHAPES dataset was introduced by Andreas et al. $\\left( 2 0 1 6 \\right)$ , and originally created for testing compositional visual reasoning for the task of visual question answering. It consists of synthetic images of 2D colored shapes arranged in a grid ( $3 \\times 3$ cells in the original dataset) along with corresponding question-answer pairs. There are 3 shapes (circle, square, triangle), 3 colors (red, green, blue), and 2 sizes (small, big) in total (see Figure 2). ",
+        "bbox": [
+            174,
+            747,
+            825,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We convert each image from SHAPES into an active environment where agents can now be spawned at different regions of the image, observe a $5 \\times 5$ local patch around them and their coordinates, and take actions to move around – tup, down, left, right, stayu. Each agent is tasked with navigating to a specified goal state in the environment – t‘red’, ‘blue square’, ‘small green circle’, etc. $\\} -$ and the reward for each agent at every timestep is based on team performance i.e. $\\begin{array} { r } { r _ { t } = \\frac { \\# \\mathrm { a g e n t s ~ o n ~ g o a l } } { \\# \\mathrm { a g e n t s } } } \\end{array}$ ",
+        "bbox": [
+            173,
+            824,
+            825,
+            897
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/4576e03e27c2832c081c391c28c88faecf612a0969853f4bbfb04e6b85fbf912.jpg",
+        "image_caption": [
+            "(a) 4 agents have to find rred, red, green, blues respectively. $t = 1$ : inital spawn locations; $t = 2$ : 4 was on red at $t = 1$ so 1 and 2 attend to messages from 4 since they have to find red. 3 has found its goal (green) and is self-attending; $t = 6$ : 4 attends to messages from 2 as 2 is on $4$ ’s target – blue; $t = 8$ : 1 finds red, so 1 and 2 shift attention to 1; $t = 2 1$ : all agents are at their respective goal locations and primarily self-attending. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            825,
+            313
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5b777d28b1efa0d622687ea099c17e88ae1f39400c36192a6b9de31d75798b7.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            378,
+            825,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(b) 8 agents have to find red on a large $1 0 0 \\times 1 0 0$ environment. $t = 7$ : Agent 2 finds red and signals all other agents; $t = 7$ to $t = 1 5 0$ : All agents make their way to 2’s location and eventually converge around red. ",
+        "bbox": [
+            176,
+            648,
+            821,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1478d00053184ca9eee6902d2c407db53d92fcaf989a971370d4965ed8e873a4.jpg",
+        "table_caption": [
+            "Figure 2: Visualizations of learned targeted communication in SHAPES. Figure best viewed in color. "
+        ],
+        "table_footnote": [
+            "Table 2: Success rates on 3 different settings of cooperative navigation in the SHAPES environment. "
+        ],
+        "table_body": "<table><tr><td></td><td></td><td></td><td>30 × 30,4agents,find[red]50 × 50,4agents,find[red]50 × 50,4agents,find[red,red,green,blue]</td></tr><tr><td>No communication</td><td>95.3±2.8%</td><td>83.6±3.3%</td><td>69.1±4.6%</td></tr><tr><td>No attention</td><td>99.7±0.8%</td><td>89.5±1.4%</td><td>82.4±2.1%</td></tr><tr><td>TarMAC</td><td>99.8±0.9%</td><td>89.5±1.7%</td><td>85.8±2.5%</td></tr></table>",
+        "bbox": [
+            173,
+            713,
+            843,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Having a symmetric, team-based reward incentivizes agents to cooperate with each other in finding each agent’s goal. For example, as shown in Figure 2a, if agent 2’s goal is to find red and agent 4’s goal is to find blue, it is in agent 4’s interest to let agent 2 know if it passes by red $( t = 2$ ) during its exploration / quest for blue and vice versa $( t = 6$ ). SHAPES serves as a flexible testbed for carefully controlling and analyzing the effect of changing the size of the environment, no. of agents, goal configurations, etc. Figure 2 visualizes learned protocols from two different configurations, and Table 2 reports quantitative evaluation for three different configurations. Benefits of communication and attention increase with task complexity ( $3 0 \\times 3 0 \\to 5 0 \\times 5 0$ & findrreds findrred,red,green,blues). ",
+        "bbox": [
+            173,
+            813,
+            826,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "How does targeting work in the communication learnt by TarMAC? Recall that each agent predicts a signature and value vector as part of the message it sends, and a query vector to attend to incoming messages. The communication is targeted because the attention probabilities are a function of both the sender’s signature and receiver’s query vectors. So it is not just the receiver deciding how much of each message to listen to. The sender also sends out signatures that affects how much of each message is sent to each receiver. The sender’s signature could encode parts of its observation most relevant to other agents’ goals (for example, it would be futile to convey coordinates in the signature), and the message value could contain the agent’s own location. For example, in Figure 2a, at $t = 6$ , we see that when agent 2 passes by blue, agent 4 starts attending to agent 2. Here, agent 2’s signature encodes the color it observes (which is blue), and agent 4’s query encodes its goal (which is also blue) leading to high attention probability. Agent 2’s message value encodes coordinates agent 4 has to navigate to, as can be seen at $t = 2 1$ when agent 4 reaches there. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 TRAFFIC JUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            292,
+            349,
+            306
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/28ad059aed1b166bde01554a2402a2d2c88626de8f5e2bf638e3f774b0449da6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Easy</td><td>Hard</td></tr><tr><td>No communication</td><td>84.9±4.3%</td><td>74.1±3.9%</td></tr><tr><td>CommNets (Sukhbaatar et al., 2016)</td><td>99.7±0.1%</td><td>78.9±3.4%</td></tr><tr><td>TarMAC 1-stage</td><td>99.9±0.1%</td><td>84.6±3.2%</td></tr><tr><td>TarMAC 2-stage</td><td>99.9±0.1%</td><td>97.1±1.6%</td></tr></table>",
+        "bbox": [
+            176,
+            361,
+            557,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Success rates on traffic junction. Our targeted 2-stage communication architecture gets a success rate of $9 7 . 1 \\%$ on the ‘hard’ variant of the task, significantly outperforming Sukhbaatar et al. (2016). Note that $1 \\mathrm { - }$ and 2-stage refer to the number of rounds of communication between actions (Equation 4). ",
+        "bbox": [
+            173,
+            449,
+            558,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/42c7b922f493e22504b75c747cefd681495b7fc95cebf19d4767eacbe462fc43.jpg",
+        "image_caption": [
+            "Figure 3: Success rates for 1 vs. 2-stage vs. message size on Hard. Performance does not decrease significantly even when the message vector is a single scalar, and 2 rounds of back-and-forth communication before taking an environment action leads to a significant improvement over 1-stage. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            576,
+            303,
+            813,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/484b7250cf4ef991db8bb33f64c548095baaf4a169dd981655636de939bfa65f.jpg",
+        "image_caption": [
+            "(c) No. of cars being attended to. 1) is positively correlated with total cars, indicating that TarMAC is adaptive to dynamic team sizes, and 2) is slightly right-shifted, since it takes few steps of communication to adapt. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            521,
+            540,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(a) Brake probabilities at dif- (b) Attention probabilities at ferent locations on the hard different locations. Cars are traffic junction environment. most attended to in the ‘interCars tend to brake close to or nal grid’ – right after the 1st right before entering junctions. junction and before the 2nd. ",
+        "bbox": [
+            173,
+            655,
+            549,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/187ff4300ed4c435b4a7b5a33a4739e5aee142e7ad4153d00b44202b62550544.jpg",
+        "image_caption": [
+            "Figure 4: Results on the traffic junction environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            570,
+            542,
+            803,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Environment and Task. The simulated traffic junction environments from Sukhbaatar et al. (2016) consist of cars moving along pre-assigned, potentially intersecting routes on one or more road junctions. The total number of cars is fixed at $N _ { \\mathrm { m a x } }$ and at every timestep, new cars get added to the environment with probability $p _ { \\mathrm { a r r i v e } }$ . Once a car completes its route, it becomes available to be sampled and added back to the environment with a different route assignment. Each car has a limited visibility of a $3 \\times 3$ region around it, but is free to communicate with all other cars. The action space for each car at every timestep is gas and brake, and the reward consists of a linear time penalty $- 0 . 0 1 \\tau$ , where $\\tau$ is the number of timesteps since car has been active, and a collision penalty $r _ { \\mathrm { c o l l i s i o n } } = - 1 0$ . ",
+        "bbox": [
+            173,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Quantitative Results. We compare our approach with CommNets (Sukhbaatar et al., 2016) on the easy and hard difficulties of the traffic junction environment. The easy task has one junction of two one-way roads on a $7 \\times 7$ grid with $N _ { \\mathrm { m a x } } ~ = ~ 5$ and $p _ { \\mathrm { a r r i v e } } ~ = ~ 0 . 3 0$ , while the hard task has four connected junctions of two-way roads on a $1 8 \\times 1 8$ grid with $N _ { \\mathrm { m a x } } = 2 0$ and $p _ { \\mathrm { a r r i v e } } = 0 . 0 5$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "See Figure 4a, 4b for an example of the four two-way junctions in the hard task. As shown in Table 3, a no communication baseline has success rates of $8 4 . 9 \\%$ and $7 4 . 1 \\%$ on easy and hard respectively. On easy, both CommNets and TarMAC get close to $1 0 0 \\%$ . On hard, TarMAC with 1-stage communication significantly outperforms CommNets with a success rate of $8 4 . 6 \\%$ , while 2- stage further improves on this at $9 7 . 1 \\%$ , which is an $\\sim 1 8 \\%$ absolute improvement over CommNets. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Model Interpretation. Interpreting the learned policies, Figure 4a shows braking probabilities at different locations: cars tend to brake close to or right before entering traffic junctions, which is reasonable since junctions have the highest chances for collisions. ",
+        "bbox": [
+            176,
+            180,
+            821,
+            222
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Turning our attention to attention probabilities (Figure $4 \\mathrm { b }$ ), we can see that cars are most-attended to when in the ‘internal grid’ – right after crossing the 1st junction and before hitting the 2nd junction. These attention probabilities are intuitive: cars learn to attentively attend to specific sensitive locations with the most relevant local observations to avoid collisions. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, Figure 4c compares total number of cars in the environment vs. number of cars being attended to with probability $> 0 . 1$ at any time. Interestingly, these are (loosely) positively correlated, with Spearman’s $\\sigma = 0 . 4 9$ , which shows that TarMAC is able to adapt to variable number of agents. Crucially, agents learn this dynamic targeting behavior purely from task rewards with no handcoding! Note that the right shift between the two curves is expected, as it takes a few timesteps of communication for team size changes to propagate. At a relative time shift of 3, the Spearman’s rank correlation between the two curves goes up to 0.53. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            390
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Message size vs. multi-stage communication. We study performance of TarMAC with varying message value size and number of rounds of communication on the ‘hard’ variant of the traffic junction task. As can be seen in Figure 3, multiple rounds of communication leads to significantly higher performance than simply increasing message size, demonstrating the advantage of multistage communication. In fact, decreasing message size to a single scalar performs almost as well as 64-d, perhaps because even a single real number can be sufficiently partitioned to cover the space of meanings/messages that need to be conveyed for this task. ",
+        "bbox": [
+            173,
+            397,
+            825,
+            494
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 HOUSE3D ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            287,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we benchmark TarMAC on a cooperative point-goal navigation task in House3D (Wu et al., 2018). House3D provides a rich and diverse set of publicly-available2 3D indoor environments, wherein agents do not have access to the top-down map and must navigate purely from first-person vision. Similar to SHAPES, the agents are tasked with finding a specified goal (such as ‘fireplace’), spawned at random locations in the environment and allowed to communicate with each other and move around. Each agent gets a shaped reward based on progress towards the specified target. An episode is successful if all agents end within $0 . 5 \\mathrm { m }$ of the target object in 50 navigation steps. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows success rates on a find[fireplace] task in House3D. A no-communication navigation policy trained with the same reward structure gets a success rate of $6 2 . 1 \\%$ . Mean-pooled communication (no attention) performs slightly better with a success rate of $6 4 . 3 \\%$ , and TarMAC achieves the best success rate at $6 8 . 9 \\%$ . Figure 5 visualizes predicted navigation trajectories of 4 agents. Note that the communication vectors are significantly more compact (32-d) than the high-dimensional observation space, making our approach particularly attractive for scaling to large teams. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/90792fae6324696f0adf1bfd7f7d85993bb5ff8a7c501d9f8024edbd11702871.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: Success rates on a 4-agent cooperative find[fireplace] navigation task in House3D. "
+        ],
+        "table_body": "<table><tr><td></td><td>Success rate</td></tr><tr><td>No communication</td><td>62.1±5.3%</td></tr><tr><td>No attention</td><td>64.3±2.3%</td></tr><tr><td>TarMAC</td><td>68.9±1.1%</td></tr></table>",
+        "bbox": [
+            372,
+            726,
+            624,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            835,
+            504,
+            853
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We introduced TarMAC, an architecture for multi-agent reinforcement learning which allows targeted interactions between agents and multiple stages of collaborative reasoning at every timestep. ",
+        "bbox": [
+            176,
+            864,
+            823,
+            892
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f196b2ffbc786f91e8cbfc725e81b5f6b5171e6de9fdeaaa94ccbb8e898f5059.jpg",
+        "image_caption": [
+            "Figure 5: Agents navigating to the fireplace in House3D (marked in yellow). Note in particular that agent 4 is spawned facing away from it. It communicates with others, turns to face the fireplace, and moves towards it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            821,
+            199
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on three diverse environments show that our model is able to learn intuitive attention behavior and improves performance, with downstream task-specific team reward as sole supervision. ",
+        "bbox": [
+            173,
+            253,
+            821,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While multi-agent navigation experiments in House3D show promising performance, we aim to exhaustively benchmark TarMAC on more challenging 3D navigation tasks because we believe this is where decentralized targeted communication can have the most impact – as it allows scaling to a large number of agents with large observation spaces. Given that the 3D navigation problem is hard in and of itself, it would be particularly interesting to investigate combinations with recent advances orthogonal to our approach (e.g. spatial memory, planning networks) with the TarMAC framework. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            393,
+            285,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural Module Networks. In CVPR, 2016. 2, 5 ",
+        "bbox": [
+            173,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "L. Busoniu, R. Babuska, and B. De Schutter. A Comprehensive Survey of Multiagent Reinforcement Learning. Trans. Sys. Man Cyber Part C, 2008. 2 ",
+        "bbox": [
+            173,
+            455,
+            823,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In EMNLP, 2014. 4 ",
+        "bbox": [
+            173,
+            492,
+            821,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Das, Satwik Kottur, José M.F. Moura, Stefan Lee, and Dhruv Batra. Learning Cooperative Visual Dialog Agents with Deep Reinforcement Learning. In ICCV, 2017. 3 ",
+        "bbox": [
+            173,
+            545,
+            823,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Yannis M Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In NIPS, 2016. 1, 2, 3 ",
+        "bbox": [
+            174,
+            583,
+            821,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In AAAI, 2018. 2, 4 ",
+        "bbox": [
+            174,
+            622,
+            821,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthew Hausknecht and Peter Stone. Deep Recurrent Q-Learning for Partially Observable MDPs. In AAAI, 2015. 2 ",
+        "bbox": [
+            173,
+            661,
+            823,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yedid Hoshen. VAIN: Attentional multi-agent predictive modeling. In NIPS. 2017. 2, 3 ",
+        "bbox": [
+            171,
+            699,
+            750,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Wojciech M. Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C. Rabinowitz, Ari S. Morcos, Avraham Ruderman, Nicolas Sonnerat, Tim Green, Louise Deason, Joel Z. Leibo, David Silver, Demis Hassabis, Koray Kavukcuoglu, and Thore Graepel. Human-level performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv preprint arXiv:1807.01281, 2018. 2 ",
+        "bbox": [
+            174,
+            724,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. CoRR, 2018. 3 ",
+        "bbox": [
+            171,
+            804,
+            821,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emilio Jorge, Mikael Kågebäck, and Emil Gustavsson. Learning to play guess who? and inventing a grounded language as a consequence. In NIPS workshop on Deep Reinforcement Learning, 2016. 3 ",
+        "bbox": [
+            174,
+            843,
+            821,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Satwik Kottur, José MF Moura, Stefan Lee, and Dhruv Batra. Natural language does not emerge ‘naturally’ in multi-agent dialog. In EMNLP, 2017. 3 ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In ICLR, 2017. 3 ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actorcritic for mixed cooperative-competitive environments. In NIPS, 2017. 2, 3, 4 ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. arXiv preprint arXiv:1703.04908, 2017. 3 ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Frans A. Oliehoek. Decentralized POMDPs. In Reinforcement Learning: State of the Art. Springer Berlin Heidelberg, 2012. 3 ",
+        "bbox": [
+            173,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "OpenAI. OpenAI Five. https://blog.openai.com/openai-five/, 2018. 2 ",
+        "bbox": [
+            173,
+            253,
+            658,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peng Peng, Quan Yuan, Ying Wen, Yaodong Yang, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent bidirectionally-coordinated nets for learning to play starcraft combat games. arXiv preprint arXiv:1703.10069, 2017. 2 ",
+        "bbox": [
+            176,
+            277,
+            825,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoav Shoham and Kevin Leyton-Brown. Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. Cambridge University Press, 2008. 2 ",
+        "bbox": [
+            171,
+            329,
+            825,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Learning multiagent communication with backpropagation. In NIPS, 2016. 1, 2, 3, 7 ",
+        "bbox": [
+            171,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, 1998. 3, 4 ",
+        "bbox": [
+            173,
+            405,
+            823,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS, 2017. 5 ",
+        "bbox": [
+            169,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yi Wu, Yuxin Wu, Georgia Gkioxari, and Yuandong Tian. Building Generalizable Agents With a Realistic And Rich 3D Environment. arXiv preprint arXiv:1801.02209, 2018. 2, 8 ",
+        "bbox": [
+            171,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In NIPS, 2017. 2 ",
+        "bbox": [
+            171,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 9
+    }
+]

parse/train/H1xQVn09FX/H1xQVn09FX_content_list.json

@@ -0,0 +1,1379 @@
+[
+    {
+        "type": "text",
+        "text": "GANSYNTH: ADVERSARIAL NEURAL AUDIO SYNTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            696,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jesse Engel, Kumar Krishna Agrawal, Shuo Chen, Ishaan Gulrajani, Chris Donahue,   \n& Adam Roberts   \nGoogle AI   \nMountain View, CA 94043, USA ",
+        "bbox": [
+            184,
+            170,
+            779,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Efficient audio synthesis is an inherently difficult machine learning task, as human perception is sensitive to both global structure and fine-scale waveform coherence. Autoregressive models, such as WaveNet, model local structure but have slow iterative sampling and lack global latent structure. In contrast, Generative Adversarial Networks (GANs) have global latent conditioning and efficient parallel sampling, but struggle to generate locally-coherent audio waveforms. Herein, we demonstrate that GANs can in fact generate high-fidelity and locally-coherent audio by modeling log magnitudes and instantaneous frequencies with sufficient frequency resolution in the spectral domain. Through extensive empirical investigations on the NSynth dataset, we demonstrate that GANs are able to outperform strong WaveNet baselines on automated and human evaluation metrics, and efficiently generate audio several orders of magnitude faster than their autoregressive counterparts.1 ",
+        "bbox": [
+            233,
+            296,
+            764,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            336,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural audio synthesis, training generative models to efficiently produce audio with both highfidelity and global structure, is a challenging open problem as it requires modeling temporal scales over at least five orders of magnitude ( ${ \\sim } 0 . 1 \\mathrm { m s }$ to ${ \\sim } 1 0 0 \\mathrm { s } ,$ ). Large advances in the state-of-the art have been pioneered almost exclusively by autoregressive models, such as WaveNet, which solve the scale problem by focusing on the finest scale possible (a single audio sample) and rely upon external conditioning signals for global structure (van den Oord et al., 2016). This comes at the cost of slow sampling speed, since they rely on inefficient ancestral sampling to generate waveforms one audio sample at a time. Due to their high quality, a lot of research has gone into speeding up generation, but the methods introduce significant overhead such as training a secondary student network or writing highly customized low-level kernels (van den Oord et al., 2018; Paine et al., 2016). Furthermore, since these large models operate at a fine timescale, their autoencoder variants are restricted to only modeling local latent structure due to memory constraints (Engel et al., 2017). ",
+        "bbox": [
+            174,
+            542,
+            825,
+            709
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "On the other end of the spectrum, Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have seen great recent success at generating high resolution images (Radford et al., 2016; Arjovsky et al., 2017; Gulrajani et al., 2017; Berthelot et al., 2017; Kodali et al., 2017; Karras et al., 2018a; Miyato et al., 2018). Typical GANs achieve both efficient parallel sampling and global latent control by conditioning a stack of transposed convolutions on a latent vector, The potential for audio GANs extends further, as adversarial costs have unlocked intriguing domain transformations for images that could possibly have analogues in audio (Isola et al., 2017; Zhu et al., 2017; Wolf et al., 2017; Jin et al., 2017). However, attempts to adapt image GAN architectures to generate waveforms in a straightforward manner (Donahue et al., 2019) fail to reach the same level of perceptual fidelity as their image counterparts. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            856
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/accf3d02b14949732afe525ce95cfafbfdb1ac012f0ed8ef2a6ebd8e9c9e47c1.jpg",
+        "image_caption": [
+            "Figure 1: Frame-based estimation of audio waveforms. Much of sound is made up of locallycoherent waves with a local periodicity, pictured as the red-yellow sinusoid with black dots at the start of each cycle. Frame-based techniques, whether they be transposed convolutions or STFTs, have a given frame size and stride, here depicted as equal with boundaries at the dotted lines. The alignment between the two (phase, indicated by the solid black line and yellow boxes), precesses in time since the periodicity of the audio and the output stride are not exactly the same. Transposed convolutional filters thus have the difficult task of covering all the necessary frequencies and all possible phase alignments to preserve phase coherence. For an STFT, we can unwrap the phase over the $2 \\pi$ boundary (orange boxes) and take its derivative to get the instantaneous radial frequency (red boxes), which expresses the constant relationship between audio frequency and frame frequency. The spectra are shown for an example trumpet note from the NSynth dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            104,
+            821,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 GENERATING INSTRUMENT TIMBRES",
+        "text_level": 1,
+        "bbox": [
+            178,
+            582,
+            472,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "GAN researchers have made rapid progress in image modeling by evaluating models on focused datasets with limited degrees of freedom, and gradually stepping up to less constrained domains. For example, the popular CelebA dataset (Liu et al., 2015) is restricted to faces that have been centered and cropped, removing variance in posture and pose, and providing a common reference for qualitative improvements (Radford et al., 2016; Karras et al., 2018a) in generating realistic texture and fine-scale features. Later models then built on that foundation to generalize to broader domains (Karras et al., 2018b; Brock et al., 2019). ",
+        "bbox": [
+            174,
+            607,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The NSynth dataset (Engel et al., $2 0 1 7 ) ^ { 2 }$ was introduced with similar motivation for audio. Rather than containing all types of audio, NSynth consists solely of individual notes from musical instruments across a range of pitches, timbres, and volumes. Similar to CelebA, all the data is aligned and cropped to reduce variance and focus on fine-scale details, which in audio corresponds to timbre and fidelity. Further, each note is also accompanied by an array of attribute labels to enable exploring conditional generation. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The original NSynth paper introduced both autoregressive WaveNet autoencoders and bottleneck spectrogram autoencoders, but without the ability to unconditionally sample from a prior. Follow up work has explored diverse approaches including frame-based regression models (Defossez et al., 2018), inverse scattering networks (Andreux & Mallat, 2018), VAEs with perceptual priors (Esling et al., 2018), and adversarial regularization for domain transfer (Mor et al., 2019). This work builds on these efforts by introducing adversarial training and exploring effective representations for noncausal convolutional generation as typical found in GANs. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.2 EFFECTIVE AUDIO REPRESENTATIONS FOR GANS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            562,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike images, most audio waveforms—such as speech and music—are highly periodic. Convolutional filters trained for different tasks on this data commonly learn to form logarithmically-scaled frequency selective filter banks spanning the range of human hearing (Dieleman & Schrauwen, 2014; Zhu et al., 2016). Human perception is also highly sensitive to discontinuities and irregularities in periodic waveforms, so maintaining the regularity of periodic signals over short to intermediate timescales $( 1 \\mathrm { { m s } - 1 0 0 \\mathrm { { m s } ) } }$ is crucial. Figure 1 shows that when the stride of the frames does not exactly equal a waveform’s periodicity, the alignment (phase) of the two precesses over time. This condition is assured as at any time there are typically many different frequencies in a given signal. This is a challenge for a synthesis network, as it must learn all the appropriate frequency and phase combinations and activate them in just the right combination to produce a coherent waveform. This phase precession is exactly the same phenomena observed with a short-time Fourier transform (STFT), which is composed of strided filterbanks just like convolutional networks. Phase precession also occurs in situations where filterbanks overlap (window or kernel size $<$ stride). ",
+        "bbox": [
+            174,
+            130,
+            825,
+            310
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the middle of Figure 1, we diagram another approach to generating coherent waveforms loosely inspired by the phase vocoder (Dolson, 1986). A pure tone produces a phase that precesses. Unwrapping the phase, by adding $2 \\pi$ whenever it crosses a phase discontinuity, causes the precessing phase to grow linearly. We then observe that the derivative of the unwrapped phase with respect to time remains constant and is equal to the angular difference between the frame stride and signal periodicity. This is commonly referred to as the instantaneous angular frequency, and is a time varying measure of the true signal oscillation. With a slight abuse of terminology we will simply refer to it as the instantaneous frequency (IF) (Boashash, 1992). Note that for the spectra at the bottom of Figure 1, the pure harmonic frequencies of a trumpet cause the wrapped phase spectra to oscillate at different rates while the unwrapped phase smoothly diverges and the IF spectra forms solid bands where the harmonic frequencies are present. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.3 CONTRIBUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            333,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we investigate the interplay of architecture and representation in synthesizing coherent audio with GANs. Our key findings include: ",
+        "bbox": [
+            174,
+            515,
+            823,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Generating log-magnitude spectrograms and phases directly with GANs can produce more coherent waveforms than directly generating waveforms with strided convolutions.   \n• Estimating IF spectra leads to more coherent audio still than estimating phase.   \n• It is important to keep harmonics from overlapping. Both increasing the STFT frame size and switching to mel frequency scale improve performance by creating more separation between the lower harmonic frequencies. Harmonic frequencies are multiples of the fundamental, so low pitches have tightly-spaced harmonics, which can cause blurring and overlap.   \n• On the NSynth dataset, GANs can outperform a strong WaveNet baseline in automatic and human evaluations, and generate examples ${ \\sim } 5 4 { , } 0 0 0$ times faster.   \n• Global conditioning on latent and pitch vectors allow GANs to generate perceptually smooth interpolation in timbre, and consistent timbral identity across pitch. ",
+        "bbox": [
+            215,
+            555,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            767,
+            415,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            279,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We focus our study on the NSynth dataset, which contains 300,000 musical notes from 1,000 different instruments aligned and recorded in isolation. NSynth is a difficult dataset composed of highly diverse timbres and pitches, but it is also highly structured with labels for pitch, velocity, instrument, and acoustic qualities (Liu et al., 2015; Engel et al., 2017). Each sample is four seconds long, and sampled at 16kHz, giving 64,000 dimensions. As we wanted to included human evaluations on audio quality, we restricted ourselves to training on the subset of acoustic instruments and fundamental pitches ranging from MIDI 24-84 (∼32-1000Hz), as those timbres are most likely to sound natural to an average listener. This left us with 70,379 examples from instruments that are mostly strings, brass, woodwinds, and mallets. We created a new test/train 80/20 split from shuffled data, as the original split was divided along instrument type, which isn’t desirable for this task. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 ARCHITECTURE AND REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            170,
+            495,
+            184
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Taking inspiration from successes in image generation, we adapt the progressive training methods of Karras et al. (2018a) to instead generate audio spectra 3. While e search over a variety of hyperparameter configurations and learning rates, we direct readers to the original paper for an in-depth analysis (Karras et al., 2018a), and the appendix for complete details. ",
+        "bbox": [
+            174,
+            199,
+            823,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Briefly, the model samples a random vector $\\mathbf { z }$ from a spherical Gaussian, and runs it through a stack of transposed convolutions to upsample and generate output data $x = G ( \\mathbf { z } )$ , which is fed into a discriminator network of downsampling convolutions (whose architecture mirrors the generator’s) to estimate a divergence measure between the real and generated distributions (Arjovsky et al., 2017). As in Karras et al. (2018a), we use a gradient penalty (Gulrajani et al., 2017) to promote Lipschitz continuity, and pixel normalization at each layer. We also try training both progressive and nonprogressive variants, and see comparable quality in both. While it is not essential for success, we do see slightly better convergence time and sample diversity for progressive training, so for the remainder of the paper, all models are compared with progressive training. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unlike Progressive GAN, our method involves conditioning on an additional source of information. Specifically, we append a one-hot representation of musical pitch to the latent vector, with the musically-desirable goal of achieving independent control of pitch and timbre. To encourage the generator to use the pitch information, we also add an auxiliary classification (Odena et al., 2017) loss to the discriminator that tries to predict the pitch label. ",
+        "bbox": [
+            174,
+            393,
+            823,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For spectral representations, we compute STFT magnitudes and phase angles using TensorFlow’s built-in implementation. We use an STFT with 256 stride and 1024 frame size, resulting in $7 5 \\%$ frame overlap and 513 frequency bins. We trim the Nyquist frequency and pad in time to get an “image” of size (256, 512, 2). The two channel dimension correspond to magnitude and phase. We take the log of the magnitude to better constrain the range and then scale the magnitudes to be between -1 and 1 to match the tanh output nonlinearity of the generator network. The phase angle is also scaled to between -1 and 1 and we refer to these variants as “phase” models. We optionally unwrap the phase angle and take the finite difference as in Figure 1; we call the resulting models “instantaneous frequency” (“IF”) models. We also find performance is sensitive to having sufficient frequency resolution at the lower frequency range. Maintaining $7 5 \\%$ overlap we are able to double the STFT frame size and stride, resulting in spectral images with size (128, 1024, 2), which we refer to as high frequency resolution, $\\mathbf { \\ddot { \\mathbf { \\mathbf { \\mathbf { \\mathbf { \\mathbf { \\mathbf { \\mathbf } } } } } } } } + \\mathbf { \\mathbf { \\mathbf { H } } } \\mathbf { \\boldsymbol { \\mathbf { \\boldsymbol { \\mathbf { \\mathit { \\mathbf { \\mathbf { \\mathbf } } } } } } } }$ , variants. Lastly, to provide even more separation of lower frequencies we transform both the log magnitudes and instantaneous frequencies to a mel frequency scale without dimensional compression (1024 bins), which we refer to as “IF-Mel” variants. To convert back to linear STFTs we just use the approximate inverse linear transformation, which, perhaps surprisingly does not harm audio quality significantly. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is important for us to compare against strong baselines, so we adapt WaveGAN (Donahue et al., 2019), the current state of the art in waveform generation with GANs, to accept pitch conditioning and retrain it on our subset of the NSynth dataset. We also independently train our own waveform generating GANs off the progressive codebase and our best models achieve similar performance to WaveGAN without progressive training, so we opt to primarily show numbers from WaveGAN instead (see appendix Table 2 for more details). ",
+        "bbox": [
+            174,
+            699,
+            825,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Beyond GANs, WaveNet (van den Oord et al., 2016) is currently the state of the art in generative modeling of audio. Prior work on the NSynth dataset used an WaveNet autoencoder to interpolate between sounds (Engel et al., 2017), but is not a generative model as it requires conditioning on the original audio. Thus, we create strong WaveNet baselines by adapting the architecture to accept the same one-hot pitch conditioning signal as the GANs. We train variants using both a categorical 8-bit mu law and 16-bit mixture of logistics for the output distributions, but find that the 8-bit model is more stable and outperforms the 16-bit model (see appendix Table 2 for more details). ",
+        "bbox": [
+            174,
+            790,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 METRICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            284,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Evaluating generative models is itself a difficult problem: because our goals (perceptually-realistic audio generation) are hard to formalize, the most common evaluation metrics tend to be heuristic and have “blind spots” (Theis et al., 2016). To mitigate this, we evaluate all of our models against a diverse set of metrics, each of which captures a distinct aspect of model performance. Our evaluation metrics are as follows: ",
+        "bbox": [
+            176,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Human Evaluation We use human evaluators as our gold standard of audio quality because it is notoriously hard to measure in an automated manner. In the end, we are interested in training networks to synthesize coherent waveforms, specifically because human perception is extremely sensitive to phase irregularities and these irregularities are disruptive to a listener. We used Amazon Mechanical Turk to perform a comparison test on examples from all models presented in Table 1 (this includes the hold-out dataset). The participants were presented with two 4s examples corresponding to the same pitch. On a five-level Likert scale, the participants evaluate the statement ”Sample A has better audio quality / has less audio distortions than Sample $B ^ { \\prime \\prime }$ . For the study, we collected 3600 ratings and each model is involved in 800 comparisons.   \n• Number of Statistically-Different Bins (NDB) We adopt the metric proposed by Richardson & Weiss (2018) to measure the diversity of generated examples: the training examples are clustered into $k = 5 0$ Voronoi cells by $k$ -means in log-spectrogram space, the generated examples are also mapped into the same space and are assigned to the nearest cell. NDB is reported as the number of cells where the number of training examples is statistically significantly different from the number of generated examples by a two-sample Binomial test.   \n• Inception Score (IS) (Salimans et al., 2016) propose a metric for evaluating GANs which has become a de-facto standard in GAN literature (Gulrajani et al., 2017; Miyato et al., 2018; Karras et al., 2018a). Generated examples are run through a pretrained Inception classifier and the Inception Score is defined as the mean KL divergence between the imageconditional output class probabilities and the marginal distribution of the same. IS penalizes models whose examples aren’t each easily classified into a single class, as well as models whose examples collectively belong to only a few of the possible classes. Though we still call our metric “IS” for consistency, we replace the Inception features with features from a pitch classifier trained on spectrograms of our acoustic NSynth dataset.   \n• Pitch Accuracy (PA) and Pitch Entropy (PE) Because the Inception Score can conflate models which don’t produce distinct pitches and models which produce only a few pitches, we also separately measure the accuracy of the same pretrained pitch classifier on generated examples (PA) and the entropy of its output distribution (PE).   \n• Frechet Inception Distance (FID) ´ (Heusel et al., 2017) propose a metric for evaluating GANs based on the 2-Wasserstein (or Frechet) distance between multivariate Gaussians fit ´ to features extracted from a pretrained Inception classifier and show that this metric correlates with perceptual quality and diversity on synthetic distributions. As with Inception Score, we use pitch-classifier features instead of Inception features. ",
+        "bbox": [
+            215,
+            204,
+            825,
+            732
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            281,
+            761
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1 presents a summary of our results on all model and representation variants. Our most discerning measure of audio quality, human evaluation, shows a clear trend, summarized in Figure 2. Quality decreases as output representations move from IF-Mel, IF, Phase, to Waveform. The highest quality model, IF-Mel, was judged comparably but slightly inferior to real data. The WaveNet baseline produces high-fidelity sounds, but occasionally breaks down into feedback and self oscillation, resulting in a score that is comparable to the IF GANs. ",
+        "bbox": [
+            174,
+            776,
+            823,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While there is no a priori reason that sample diversity should correlate with audio quality, we indeed find that NDB follows the same trend as the human evaluation. Additionally, high frequency resolution improves the NDB score across models types. The WaveNet baseline receives the worst NDB score. Even though the generative model assigns high likelihood to all the training data, the autoregressive sampling itself has a tendency gravitate to the same type of oscillation for each given pitch conditioning, leading to an extreme lack of diversity. Histograms of the sample distributions showing peaky distributions for the different models can be found in the appendix. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/0ce4b37e2e619fc66faefb95841b41a43a5dd06250e8c1c26ee032e50053eea3.jpg",
+        "table_caption": [
+            "Table 1: Metrics for different models. $\\tilde { \\mathbf { \\Gamma } } + \\mathrm { H } ^ { \\prime \\prime }$ stands for higher frequency resolution, and ”Real Data” is drawn from the test set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"6\">Human Eval</td></tr><tr><td>Examples</td><td>(wins)</td><td>NDB</td><td>FID</td><td>IS</td><td>PA</td><td>PE</td></tr><tr><td>Real Data</td><td>549</td><td>2.2</td><td>13</td><td>47.1</td><td>98.2</td><td>0.22</td></tr><tr><td>IF-Mel + H</td><td>485</td><td>29.3</td><td>167</td><td>38.1</td><td>97.9</td><td>0.40</td></tr><tr><td>IF+H</td><td>308</td><td>36.0</td><td>104</td><td>41.6</td><td>98.3</td><td>0.32</td></tr><tr><td>Phase +H</td><td>225</td><td>37.6</td><td>592</td><td>36.2</td><td>97.6</td><td>0.44</td></tr><tr><td>IF-Mel</td><td>479</td><td>37.0</td><td>600</td><td>29.6</td><td>94.1</td><td>0.63</td></tr><tr><td>IF</td><td>283</td><td>37.0</td><td>708</td><td>36.3</td><td>96.8</td><td>0.44</td></tr><tr><td>Phase</td><td>203</td><td>41.4</td><td>687</td><td>24.4</td><td>94.4</td><td>0.77</td></tr><tr><td>WaveNet</td><td>359</td><td>45.9</td><td>320</td><td>29.1</td><td>92.7</td><td>0.70</td></tr><tr><td>WaveGAN</td><td>216</td><td>43.0</td><td>461</td><td>13.7</td><td>82.7</td><td>1.40</td></tr></table>",
+        "bbox": [
+            261,
+            155,
+            730,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5c79b8177204bb26d801ee19df8fafbb20f52480114e5262b09047b8ca9bab06.jpg",
+        "image_caption": [
+            "Figure 2: Number of wins on pair-wise comparison across different output representations and baselines. Ablation comparing highest performing models of each type. Higher scores represent better perceptual quality to participants. The ranking observed here correlates well with the evaluation on quantitative metrics as in Table 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            347,
+            823,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            604,
+            821,
+            647
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "FID provides a similar story to the first two metrics with significantly lower scores for for IF models with high frequency resolution. Comparatively, Mel scaling has much less of an effect on the FID then it does in the listener study. Phase models have high FID, even at high frequency resolution, reflecting their poor sample quality. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            710
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Many of the models do quite well on the classifier metrics of IS, Pitch Accuracy, and Pitch Entropy, because they have explicit conditioning telling them what pitches to generate. All of the high-resolution models actually generate examples classified with similar accuracy to the real data. As this accuracy and entropy can be a strong function of the distribution of generated examples, which most certainly does not match the training distribution due to mode collapse and other issues, there is little discriminative information to gain about sample quality from differences among such high scores. The metrics do provide a rough measure of which models are less reliably generating classifiable pitches, which seems to be the low frequency models to some extent and the baselines. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            829
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 QUALITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            410,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While we do our best to visualize qualitative audio concepts, we highly recommend the reader to listen to the accompanying audio examples provided at https://goo.gl/magenta/ gansynth-examples. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc64b1b727defb1a0bb619b511a6b99b0a1e06fc4af6257c01419b3b480e8021.jpg",
+        "image_caption": [
+            "Figure 3: Phase coherence. Examples are selected to be roughly similar between the models for illustrative purposes. The top row shows the waveform modulo the fundamental periodicity of the note (MIDI C60), for 1028 examples taken in the middle of the note. Notice that the real data completely overlaps itself as the waveform is extremely periodic. The WaveGAN and PhaseGAN, however, have many phase irregularities, creating a blurry web of lines. The IFGAN is much more coherent, having only small variations from cycle-to-cycle. In the Rainbowgrams below, the real data and IF models have coherent waveforms that result in strong consistent colors for each harmonic, while the PhaseGAN has many speckles due to phase discontinuities, and the WaveGAN model is quite irregular. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            820,
+            364
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 PHASE COHERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            531,
+            352,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 visualizes the phase coherence of examples from different GAN variants. It is clear from the waveforms at the top, which are wrapped at the fundamental frequency, that the real data and IF models produce waveforms that are consistent from cycle-to-cycle. The PhaseGAN has some phase discontinuities, while the WaveGAN is quite irregular. Below we use Rainbowgrams (Engel et al., 2017) to depict the log magnitude of the frequencies as brightness and the IF as the color on a rainbow color map. This visualization helps to see clear phase coherence of the harmonics in the real data and IFGAN by the strong consistent colors. In contrast, the PhaseGAN discontinuities appear as speckled noise, and the WaveGAN appears largely incoherent. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            669
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 INTERPOLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            328,
+            700
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As discussed in the introduction, GANs also allow conditioning on the same latent vector the entire sequence, as opposed to only short subsequences for memory intensive autoregressive models like WaveNet. WaveNet autoencoders, such as ones in (Engel et al., 2017), learn local latent codes that control generation on the scale of milliseconds but have limited scope, and have a structure of their own that must be modelled and does not fit a compact prior. In Figure 4 we take a pretrained WaveNet autoencoder 5 and compare interpolating between examples in the raw waveform (top), the distributed latent code of a WaveNet autoencoder, and the global code of an IF-Mel GAN. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Interpolating the waveform is perceptually equivalent to mixing between the amplitudes of two distinct sounds. WaveNet improves upon this for the two notes by mixing in the space of timbre, but the linear interpolation does not correspond to the complex prior on latents, and the intermediate sounds have a tendency to fall apart, oscillate and whistle, which are the natural failure modes for a WaveNet model. However, the GAN model has a spherical gaussian prior which is decoded to produce the entire sound, and spherical interpolation stays well-aligned with the prior. Thus, the perceptual change during interpolation is smooth and all intermediate latent vectors are decoded to produce sounds without additional artifacts. As a more musical example, in the audio examples, we interpolate the timbre between 15 random points in latent space while using the pitches from the prelude to Bach’s Suite No. 1 in G major 6. As seen in appendix Figure 7, the timbre of the sounds morph smoothly between many instruments while the pitches consistently follow the composed piece. ",
+        "bbox": [
+            174,
+            816,
+            823,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/25dc0d5e17ebb314d71d4e5cf63cedff4e2f3bee062c8a20902a3af0ac6213bf.jpg",
+        "image_caption": [
+            "Figure 4: Global interpolation. Examples available for listening4. Interpolating between waveforms perceptually results in crossfading the volumes of two distinct sounds (rainbowgrams at top). The WaveNet autoencoder (middle) only has local conditioning distributed in time, and no compact prior over those time series, so linear interpolation ventures off the true prior / data manifold, and produces in-between sounds that are less realistic examples and feature the default failure mode of autoregressive wavenets (feedback harmonics). Meanwhile, the IF-Mel GAN (bottom) has global conditioning so interpolating in perceptual attributes while staying along the prior at all intermediate points, so they produce high-fidelity audio examples like the endpoints. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            106,
+            823,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 CONSISTENT TIMBRE ACROSS PITCH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            696,
+            473,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While timbre slightly varies for a natural instrument across register, on the whole it remains consistent, giving the instrument its unique character. In the audio examples 7, we fix the latent conditioning variable and generate examples by varying the pitch conditioning over five octaves. It’s clear that the timbral identity of the GAN remains largely intact, creating a unique instrument identity for the given point in latent space. As seen in appendix Figure 7, the Bach prelude rendered with a single latent vector has a consistent harmonic structure across a range of pitches. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 FAST GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            364,
+            842
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One of the advantages of GANs with upsampling convolutions over autoregressive models is that the both the training and generation can be processed in parallel for the entire audio sample. This is quite amenable to modern GPU hardware which is often I/O bound with iterative autoregressive algorithms. This can be seen when we synthesize a single four second audio sample on a TitanX GPU and the latency to completion drops from 1077.53 seconds for the WaveNet baseline to 20 milliseconds for the IF-Mel GAN making it around 53,880 times faster. Previous applications of WaveNet autoencoders trained on the NSynth dataset for music performance relied on prerendering all possible sounds for playback due to the long synthesis latency 8. This work opens up the intriguing possibility for realtime neural network audio synthesis on device, allowing users to explore a much broader pallete of expressive sounds. ",
+        "bbox": [
+            176,
+            858,
+            823,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            244,
+            344,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Much of the work on deep generative models for audio tends to focus on speech synthesis (van den Oord et al., 2018; Sotelo et al., 2017; Wang et al., 2017). These datasets require handling variable length conditioning (phonemes/text) and audio, and often rely on recurrent and/or autoregressive models for variable length inputs and outputs. It would be interesting to compare adversarial audio synthesis to these methods, but we leave this to future work as adapting GANs to use variable-length conditioning or recurrent generators is a non-trivial extension of the current work. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            366
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In comparison to speech, audio generation for music is relatively under-explored. van den Oord et al. (2016) and Mehri et al. (2017) propose autoregressive models and demonstrate their ability to synthesize musical instrument sounds, but these suffer from the aforementioned slow generation. Donahue et al. (2019) first applied GANs to audio generation with coherent results, but fell short of the audio fidelity of autoregressive likelihood models. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            443
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our work also builds on multiple recent advances in GAN literature. Gulrajani et al. (2017) propose a modification to the loss function of GANs and demonstrate improved training stability and architectural robustness. Karras et al. (2018a) further introduce progressive training, in which successive layers of the generator and discriminator are learned in a curriculum, leading to improved generation quality given a limited training time. They also propose a number of architectural tricks to further improve quality, which we employ in our best models. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The NSynth dataset was first introduced as a “CelebA of audio” (Liu et al., 2015; Engel et al., 2017), and used WaveNet autoencoders to interpolate between timbres of musical instruments, but with very slow sampling speeds. Mor et al. (2019) expanded on this work by incoporating an adversarial domain confusion loss to achieve timbre transformations between a wide range of audio sources. Defossez et al. (2018) achieve significant sampling speedups $( \\sim 2 , 5 0 0 \\mathrm { x } )$ over wavenet autoencoders by training a frame-based regression model to map from pitch and instrument labels to raw waveforms. They consider a unimodal likelihood regression loss in log spectrograms and backpropagate through the STFT, which yeilds good frequency estimation, but provides no incentive to learn phase coherency or handle multimodal distributions. Their architecture also requires a large amount of channels, slowing down sample generation and training. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            679
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            318,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "By carefully controlling the audio representation used for generative modeling, we have demonstrated high-quality audio generation with GANs on the NSynth dataset, exceeding the fidelity of a strong WaveNet baseline while generating samples tens of thousands of times faster. While this is a major advance for audio generation with GANs, this study focused on a specific controlled dataset, and further work is needed to validate and expand it to a broader class of signals including speech and other types of natural sound. This work also opens up possible avenues for domain transfer and other exciting applications of adversarial losses to audio. Issues of mode collapse and diversity common to GANs exist for audio as well, and we leave it to further work to consider combining adversarial losses with encoders or more straightforward regression losses to better capture the full data distribution. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            328,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Rif A. Saurous and David Berthelot for fruitful discussions and help in reviewing the manuscript. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            178,
+            285,
+            193
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mathieu Andreux and Stephane Mallat. Music generation and transformation with moment matching-scattering inverse networks. In International Society for Music Information Retrevial Conference, 2018. URL http://ismir2018.ircam.fr/doc/pdfs/131_Paper.pdf. ",
+        "bbox": [
+            174,
+            200,
+            826,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 214–223, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http:// proceedings.mlr.press/v70/arjovsky17a.html. ",
+        "bbox": [
+            173,
+            252,
+            825,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot, Thomas Schumm, and Luke Metz. BEGAN: Boundary equilibrium generative adversarial networks. arXiv preprint arXiv:1703.10717, 2017. ",
+        "bbox": [
+            171,
+            330,
+            823,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Boualem Boashash. Estimating and interpreting the instantaneous frequency of a signal. Proceedings of the IEEE, 80(4):540–568, 1992. ",
+        "bbox": [
+            171,
+            368,
+            821,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image synthesis. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ B1xsqj09Fm. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexandre Defossez, Neil Zeghidour, Nicolas Usunier, Leon Bottou, and Francis Bach. Sing: Symbol-to-instrument neural generator. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 9041–9051. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 8118-sing-symbol-to-instrument-neural-generator.pdf. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sander Dieleman and Benjamin Schrauwen. End-to-end learning for music audio. In ICASSP, pp. 6964–6968, 2014. ",
+        "bbox": [
+            174,
+            537,
+            821,
+            566
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Dolson. The phase vocoder: A tutorial. Computer Music Journal, 10(4):14–27, 1986. ",
+        "bbox": [
+            171,
+            575,
+            776,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris Donahue, Julian McAuley, and Miller Puckette. Adversarial audio synthesis. In ICLR, 2019. ",
+        "bbox": [
+            171,
+            599,
+            818,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jesse Engel, Cinjon Resnick, Adam Roberts, Sander Dieleman, Douglas Eck, Karen Simonyan, and Mohammad Norouzi. Neural audio synthesis of musical notes with WaveNet autoencoders. In ICML, 2017. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Philippe Esling, Axel Chemla-Romeu-Santos, and Adrien Bitton. Bridging audio analysis, perception and synthesis with perceptually-regularized variational timbre spaces. In Proceedings of the 19th International Society for Music Information Retrieval Conference, ISMIR 2018, Paris, France, September 23-27, 2018, pp. 175–181, 2018. URL http://ismir2018.ircam.fr/ doc/pdfs/219_Paper.pdf. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 NIPS, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of Wasserstein GANs. In NIPS, pp. 5767–5777, 2017. ",
+        "bbox": [
+            171,
+            805,
+            823,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a local Nash equilibrium. In NIPS, pp. 6626–6637. 2017. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yanghua Jin, Jiakai Zhang, Minjun Li, Yingtao Tian, Huachun Zhu, and Zhihao Fang. Towards the automatic anime characters creation with generative adversarial networks. arXiv preprint arXiv:1708.05509, 2017. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of GANs for improved quality, stability, and variation. In ICLR, 2018a. ",
+        "bbox": [
+            173,
+            157,
+            821,
+            186
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. CoRR, abs/1812.04948, 2018b. URL http://arxiv.org/abs/1812. 04948. ",
+        "bbox": [
+            173,
+            199,
+            823,
+            241
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Naveen Kodali, Jacob Abernethy, James Hays, and Zsolt Kira. On convergence and stability of gans. arXiv preprint arXiv:1705.07215, 2017. ",
+        "bbox": [
+            173,
+            294,
+            821,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), 2015. ",
+        "bbox": [
+            171,
+            335,
+            820,
+            364
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Soroush Mehri, Kundan Kumar, Ishaan Gulrajani, Rithesh Kumar, Shubham Jain, Jose Sotelo, Aaron Courville, and Yoshua Bengio. SampleRNN: An unconditional end-to-end neural audio generation model. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            376,
+            821,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            430,
+            823,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Noam Mor, Lior Wolf, Adam Polyak, and Yaniv Taigman. Autoencoder-based music translation. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id ${ . } = { }$ HJGkisCcKm. ",
+        "bbox": [
+            173,
+            470,
+            825,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier gans. In ICML, 2017. ",
+        "bbox": [
+            171,
+            526,
+            823,
+            556
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Le Paine, Pooya Khorrami, Shiyu Chang, Yang Zhang, Prajit Ramachandran, Mark A Hasegawa-Johnson, and Thomas S Huang. Fast WaveNet generation algorithm. arXiv preprint arXiv:1611.09482, 2016. ",
+        "bbox": [
+            173,
+            566,
+            823,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In ICLR, 2016. ",
+        "bbox": [
+            171,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eitan Richardson and Yair Weiss. On GANs and GMMs. CoRR, abs/1805.12462, 2018. URL http://arxiv.org/abs/1805.12462. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            693
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In NIPS, pp. 2234–2242, 2016. ",
+        "bbox": [
+            171,
+            703,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "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. CoRR, abs/1701.05517, 2017. URL http://arxiv.org/abs/1701.05517. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jose Sotelo, Soroush Mehri, Kundan Kumar, Joao Felipe Santos, Kyle Kastner, Aaron Courville, and Yoshua Bengio. Char2wav: End-to-end speech synthesis. 2017. ",
+        "bbox": [
+            171,
+            799,
+            823,
+            829
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lucas Theis, Aaron van den Oord, and Matthias Bethge. A note on the evaluation of generative ¨ models. In ICLR, 2016. ",
+        "bbox": [
+            169,
+            840,
+            825,
+            869
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, ¨ Nal Kalchbrenner, Andrew W Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. In SSW, pp. 125, 2016. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Yazhe Li, Igor Babuschkin, Karen Simonyan, Oriol Vinyals, Koray Kavukcuoglu, George van den Driessche, Edward Lockhart, Luis Cobo, Florian Stimberg, Norman Casagrande, Dominik Grewe, Seb Noury, Sander Dieleman, Erich Elsen, Nal Kalchbrenner, Heiga Zen, Alex Graves, Helen King, Tom Walters, Dan Belov, and Demis Hassabis. Parallel WaveNet: Fast high-fidelity speech synthesis. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3918–3926, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings.mlr.press/v80/oord18a.html. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuxuan Wang, RJ Skerry-Ryan, Daisy Stanton, Yonghui Wu, Ron J Weiss, Navdeep Jaitly, Zongheng Yang, Ying Xiao, Zhifeng Chen, Samy Bengio, et al. Tacotron: Towards end-to-end speech synthesis. In INTERSPEECH, 2017. ",
+        "bbox": [
+            174,
+            224,
+            823,
+            267
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lior Wolf, Yaniv Taigman, and Adam Polyak. Unsupervised creation of parameterized avatars. CoRR, abs/1704.05693, 2017. ",
+        "bbox": [
+            176,
+            275,
+            821,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            313,
+            823,
+            342
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhenyao Zhu, Jesse H Engel, and Awni Y Hannun. Learning multiscale features directly fromwaveforms. CoRR, vol. abs/1603.09509, 2016. ",
+        "bbox": [
+            169,
+            352,
+            823,
+            380
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/db57bbd09e2d44176addffb284990fd4bbc485158a2ac319388becbd9ad155a9.jpg",
+        "image_caption": [
+            "A MEASURING DIVERSITY ACROSS GENERATED EXAMPLES "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            159,
+            761,
+            425
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/222a79b2ad32e269faae27441b4b98334300fafec679b2fc2fb77707f1eee842.jpg",
+        "image_caption": [
+            "Figure 5: NDB bin proportions for the IF-Mel $+ \\textrm { H }$ model and the WaveGAN baseline (evaluated with examples of pitch 60). ",
+            "Figure 6: NDB bin proportions for the WaveNet baseline (evaluated with examples of pitch 60). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            536,
+            764,
+            796
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B TIMBRAL SIMILARITY ACROSS PITCH ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            527,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Bach Prelude -- Single Latent Vector ",
+        "bbox": [
+            372,
+            151,
+            627,
+            166
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/7654cd0fadcb374b77e36efbaba7b697b7261985788cd5dd3775bc522c3e4059.jpg",
+        "image_caption": [
+            "Figure 7: The first 20 seconds (10 seconds per a row) of the prelude to Bach’s Suite No. 1 in G major 9, for pitches synthesized with a single latent vector (top), and with spherical interpolation in latent space (bottom). The timbre is constant for a single latent vector, shown by the consistency of the upper harmonic structure, while it varies dramatically as the latent vector changes. Listening examples are provided at https://goo.gl/magenta/gansynth-examples "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            160,
+            825,
+            484
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C BASELINE MODEL COMPARISONS",
+        "bbox": [
+            174,
+            102,
+            491,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/32e7c5e1b18d5571724ccf317da8244049c3402eaa7a55b1cf4ca7ca71e85611.jpg",
+        "table_caption": [
+            "Table 2: Comparison of models generating waveforms directly. Our Waveform GAN baseline performs similar to the WaveGAN baseline, but the progressive training does not improve performance, so we only compare to the WaveGAN baseline for the paper. The 8-bit categorical WaveNet outperforms the 16-bit mixture of logistics, likely due to the decreased stability of the 16-bit model with only pitch conditioning, despite the increased fidelity. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Examples</td><td>NDB</td><td>FID</td><td>IS</td><td>PA</td><td>PE</td></tr><tr><td>WaveGAN</td><td>43.0</td><td>461</td><td>13.7</td><td>82.7</td><td>1.40</td></tr><tr><td>Waveform NoProg</td><td>48.2</td><td>447</td><td>14.8</td><td>96.3</td><td>1.61</td></tr><tr><td>Waveform Prog</td><td>45.0</td><td>375</td><td>2.5</td><td>56.7</td><td>3.59</td></tr><tr><td>WaveNet 8-bit</td><td>44.8</td><td>320</td><td>29.1</td><td>92.7</td><td>0.70</td></tr><tr><td>WaveNet 16-bit</td><td>45.9</td><td>656</td><td>9.5</td><td>64.6</td><td>1.71</td></tr></table>",
+        "bbox": [
+            300,
+            232,
+            691,
+            332
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            374,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "GAN architectures were directly adapted from an open source implementation in Tensorflow 10. Full details are given in Table 3, including adding a pitch classifier to the end of the discriminator as in AC-GAN. All models were trained with the ADAM optimizer (Kingma & Ba, 2014). We sweep over learning rates (2e-4, 4e-4, 8e-4) and weights of the auxiliary classifier loss (0.1, 1.0, 10), and find that for all variants (spectral representation, progressive/no progressive, frequency resolution) a learning rate of 8e-4 and classifier loss of 10 perform the best. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            218
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "As in the original progressive GAN paper, both networks use box upscaling/downscaling and the generators use pixel normalization, ",
+        "bbox": [
+            174,
+            223,
+            823,
+            252
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aa6927570bf434ee0036b1b6536c363295bf0da75be466db51fb957d874c3618.jpg",
+        "text": "$$\nx = x _ { n h w c } / ( \\frac { 1 } { C } \\sum _ { c } x _ { n h w c } ^ { 2 } ) ^ { 0 . 5 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            268,
+            599,
+            306
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "where $n , h , w$ , and $c$ refer to the batch, height, width, and channel dimensions respectively, $x$ is the activations, and $C$ is the total number of channels. The discriminator also appends the standard deviation of the minibatch activations as a scalar channel near the end of the convolutional stack as seen in Table 3. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Since we find it helpful to use a Tanh output nonlinearity for the generator, we normalize real data before passing to the discriminator. We measure the maximum range over 100 examples and independently shift and scale the log-magnitudes and phases to [-0.8, 0.8] to allow for outliers and use more of the linear regime of the Tanh nonlinearity. ",
+        "bbox": [
+            174,
+            377,
+            823,
+            435
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We train each GAN variant for 4.5 days on a single V100 GPU, with a batch size of 8. For nonprogressive models, this equates to training on ${ \\sim } 5 \\mathbf { M }$ examples. For progressive models, we train on 1.6M examples per a stage (7 stages), 800k during alpha blending and $8 0 0 \\mathrm { k }$ after blending. At the last stage we continue training until the 4.5 days completes. Because the earlier stages train faster, the progressive models train on ${ \\sim } 1 1 \\mathbf { M }$ examples. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            511
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For the WaveNet baseline, we also adapt the open source Tensorflow implementation 11. The decoder is composed of 30 layers of dilated convolution, each of 512 channels and receptive field of 3, and each with a 1x1 convolution skip connection to the output. The layers are divided into 3 stacks of 10, with dilation in each stack increasing from $2 ^ { 0 }$ to $2 ^ { 9 }$ , and then repeating. We replace the audio encoder stack with a conditioning stack operating on a one-hot pitch conditioning signal distributed in time (3 seconds on, 1 second off). The conditioning stack is 5 layers of dilated convolution, increasing to $2 ^ { 5 }$ , and then 3 layers of regular convolution, all with 512 channels. This conditioning signal is then passed through a 1x1 convolution for each layer of the decoder and added to the output of each layer, as in other implementations of WaveNet conditioning. For the 8-bit model we use mulaw encoding of the audio and a categorical loss, while for the 16-bit model we use a quantized mixture of 10 logistics (Salimans et al., 2017). WaveNets converged to $1 5 0 \\mathrm { k }$ iterations in 2 days with 32 V100 GPUs trained with synchronous SGD with batch size 1 per GPU, for a total batch size of 32. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            699
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/d5949e4912d7b7733fe9da6fed27451344ed6ad63c7dd4858c317ada0825b060.jpg",
+        "table_caption": [
+            "Table 3: Model architecture for hi-frequency resolution. Low frequency resolution starts with a width of 4, and height of 8, but is otherwise the same. ”PN” stands for pixel norm, and ”LReLU” stands for leaky rectified linear unit, with a slope of 0.2. The latent vector Z has 256 dimensions and the pitch conditioning is a 61 dimensional one-hot vector. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Generator</td><td>Output Size</td><td>kwidth</td><td>kHeight</td><td>kFilters</td><td>Nonlinearity</td></tr><tr><td>concat(Z, Pitch)</td><td>(1,1,317)</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>conv2d</td><td>(2,16,256)</td><td>2</td><td>16</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>conv2d</td><td>(2, 16,256)</td><td>3</td><td>3</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>upsample 2x2</td><td>(4,32,256)</td><td></td><td></td><td></td><td></td></tr><tr><td>conv2d</td><td>(4, 32, 256)</td><td>3</td><td>3</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>conv2d</td><td>(4, 32,256)</td><td>3</td><td>3</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>upsample 2x2</td><td>(8, 64,256)</td><td>1</td><td></td><td></td><td></td></tr><tr><td>conv2d</td><td>(8, 64,256)</td><td>3</td><td>3</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>conv2d</td><td>(8, 64,256)</td><td>3</td><td>3</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>upsample 2x2</td><td>(16,128, 256)</td><td></td><td></td><td>-</td><td></td></tr><tr><td>conv2d</td><td>(16,128, 256)</td><td>3</td><td>3</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>conv2d</td><td>(16,128,256)</td><td>3</td><td>3</td><td>256</td><td>PN(LReLU)</td></tr><tr><td>upsample 2x2</td><td>(32, 256,256)</td><td>=</td><td>1</td><td></td><td></td></tr><tr><td>conv2d</td><td>(32,256, 128)</td><td>3</td><td>3</td><td>128</td><td>PN(LReLU)</td></tr><tr><td>conv2d</td><td>(32,256, 128)</td><td>3</td><td>3</td><td>128</td><td>PN(LReLU)</td></tr><tr><td>upsample 2x2</td><td>(64,512, 128)</td><td></td><td></td><td></td><td></td></tr><tr><td>conv2d</td><td>(64, 512, 64)</td><td>3</td><td>3</td><td>64</td><td>PN(LReLU)</td></tr><tr><td>conv2d</td><td>(64,512, 64)</td><td>3</td><td>3</td><td>64</td><td>PN(LReLU)</td></tr><tr><td>upsample 2x2</td><td>(128,1024, 64)</td><td>=</td><td>■</td><td>1</td><td></td></tr><tr><td>conv2d</td><td>(128,1024,32)</td><td>3</td><td>3</td><td>32</td><td>PN(LReLU)</td></tr><tr><td>conv2d</td><td>(128,1024,32)</td><td>3</td><td>3</td><td>32</td><td>PN(LReLU)</td></tr><tr><td>generator output</td><td>(128,1024,2)</td><td>1</td><td>1</td><td>2</td><td>Tanh</td></tr><tr><td>Discriminator</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>image</td><td>(128,1024,2)</td><td>1</td><td></td><td>1</td><td></td></tr><tr><td>conv2d</td><td>(128,1024,32)</td><td>1</td><td>1</td><td>32</td><td></td></tr><tr><td>conv2d</td><td>(128,1024,32)</td><td>3</td><td>3</td><td>32</td><td>LReLU</td></tr><tr><td>conv2d</td><td>(128,1024, 32)</td><td>3</td><td>3</td><td>32</td><td>LReLU</td></tr><tr><td>downsample 2x2</td><td>(64,512,32)</td><td></td><td></td><td>1</td><td></td></tr><tr><td>conv2d</td><td>(64, 512, 64)</td><td>3</td><td>3</td><td>64</td><td>LReLU</td></tr><tr><td>conv2d</td><td>(64, 512, 64)</td><td>3</td><td>3</td><td>64</td><td>LReLU</td></tr><tr><td>downsample 2x2</td><td>(32,256,64)</td><td>■</td><td></td><td>=</td><td></td></tr><tr><td>conv2d</td><td>(32, 256,128)</td><td>3</td><td>3</td><td>128</td><td>LReLU</td></tr><tr><td>conv2d</td><td>(32,256, 128)</td><td>3</td><td>3</td><td>128</td><td>LReLU</td></tr><tr><td>downsample 2x2</td><td>(16,128, 128)</td><td>1</td><td></td><td>1</td><td></td></tr><tr><td>conv2d</td><td>(16,128,256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>conv2d</td><td>(16,128, 256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>downsample 2x2</td><td>(8, 64,256)</td><td>-</td><td>1</td><td>1</td><td></td></tr><tr><td>conv2d</td><td>(8,64,256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>conv2d</td><td>(8, 64,256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>downsample 2x2</td><td>(4,32,256)</td><td></td><td>1</td><td></td><td></td></tr><tr><td>conv2d</td><td>(4,32,256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>conv2d</td><td>(4,32,256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>downsample 2x2</td><td>(2, 16,256)</td><td>1</td><td>■</td><td>1</td><td>1</td></tr><tr><td>concat(x,minibatch std.)</td><td>(2,16,257)</td><td></td><td></td><td>1</td><td></td></tr><tr><td>conv2d</td><td>(2,16,256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>conv2d</td><td>(2,16,256)</td><td>3</td><td>3</td><td>256</td><td>LReLU</td></tr><tr><td>pitch classifier</td><td>(1,1,61)</td><td></td><td></td><td>61</td><td>Softmax</td></tr><tr><td>discriminator output</td><td>(1, 1, 1)</td><td></td><td></td><td>1</td><td>1</td></tr></table>",
+        "bbox": [
+            189,
+            174,
+            805,
+            931
+        ],
+        "page_idx": 16
+    }
+]

parse/train/Hyl5V0EYvB/Hyl5V0EYvB.md

@@ -0,0 +1,416 @@
+# TESTING ROBUSTNESS AGAINST UNFORESEEN ADVERSARIES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Most existing defenses against adversarial attacks only consider robustness to $L _ { p }$ - bounded distortions. In reality, the specific attack is rarely known in advance and adversaries are free to modify images in ways which lie outside any fixed distortion model; for example, image rotations lie outside the set of $L _ { p }$ -bounded distortions. In this work, we advocate measuring robustness against a much broader range of unforeseen attacks, attacks whose precise form is unknown during defense design.
+
+We propose several new attacks and a methodology for evaluating a defense against a diverse range of unforeseen distortions. First, we construct novel adversarial JPEG, Fog, Gabor, and Snow distortions to simulate more diverse adversaries. We then introduce UAR, a summary metric that measures the robustness of a defense against a given distortion. Using UAR to assess robustness against existing and novel attacks, we perform an extensive study of adversarial robustness. We find that evaluation against existing $L _ { p }$ attacks yields redundant information which does not generalize to other attacks; we instead recommend evaluating against our significantly more diverse set of attacks. We further find that adversarial training against either one or multiple distortions fails to confer robustness to attacks with other distortion types. These results underscore the need to evaluate and study robustness against unforeseen distortions.
+
+# 1 INTRODUCTION
+
+Neural networks perform well on many benchmark tasks (He et al., 2016) yet can be fooled by adversarial examples (Goodfellow et al., 2014) or inputs designed to subvert a given model. Adversaries are usually assumed to be constrained by an $L _ { \infty }$ budget (Goodfellow et al., 2014; Madry et al., 2017; Xie et al., 2018), while other modifications such as adversarial geometric transformations, patches, and even 3D-printed objects have also been considered (Engstrom et al., 2017; Brown et al., 2017; Athalye et al., 2017). However, most work on adversarial robustness assumes that the adversary is fixed and known in advance. Defenses against adversarial attacks are often constructed in view of this specific assumption (Madry et al., 2017).
+
+In practice, adversaries can modify and adapt their attacks so that they are unforeseen. In this work, we propose novel attacks which enable the diverse assessment of robustness to unforeseen attacks. Our attacks are varied ( 2) and qualitatively distinct from current attacks. We propose adversarial JPEG, Fog, Gabor, and Snow attacks (sample images in Figure 1).
+
+We propose an unforeseen attack evaluation methodology (§3) that involves evaluating a defense against a diverse set of held-out distortions decoupled from the defense design. For a fixed, held-out distortion, we then evaluate the defense against the distortion for a calibrated range of distortion sizes whose strength is roughly comparable across distortions. For each fixed distortion, we summarize the robustness of a defense against that distortion relative to a model adversarially trained on that distortion, a measure we call UAR. We provide code and calibrations to easily evaluate a defense against our suite of attacks at https://github.com/iclr-2020-submission/ advex-uar.
+
+By applying our method to 87 adversarially trained models and 8 different distortion types (§4), we find that existing defenses and evaluation practices have marked weaknesses. Our results show that existing defenses based on adversarial training do not generalize to unforeseen adversaries, even when restricted to the 8 distortions in Figure 1. This adds to the mounting evidence that achieving robustness against a single distortion type is insufficient to impart robustness to unforeseen attacks (Jacobsen et al., 2019; Jordan et al., 2019; Tramer & Boneh, 2019). \`
+
+![](images/ae27e0b408151854ee1ac8545b5497c78e3d2093b17b785048cead2dcca9a7af.jpg)  
+Figure 1: Attacked images (label “espresso maker”) against adversarially trained models with large $\varepsilon$ . Each of the adversarial images above are optimized to maximize the classification loss.
+
+Turning to evaluation, our results demonstrate that accuracy against different $L _ { p }$ distortions is highly correlated relative to the other distortions we consider. This suggest that the common practice of evaluating only against $L _ { p }$ distortions to test a model’s adversarial robustness can give a misleading account. Our analysis demonstrates that our full suite of attacks adds substantive attack diversity and gives a more complete picture of a model’s robustness to unforeseen attacks.
+
+A natural approach is to defend against multiple distortion types simultaneously in the hope that seeing a larger space of distortions provides greater transfer to unforeseen distortions. Unfortunately, we find that defending against even two different distortion types via joint adversarial training is difficult (§5). Specifically, joint adversarial training leads to overfitting at moderate distortion sizes.
+
+In summary, we propose a metric UAR to assess robustness of defenses against unforeseen adversaries. We introduce a total of 4 novel attacks. We apply UAR to assess how robustness transfers to existing attacks and our novel attacks. Our results demonstrate that existing defense and evaluation methods do not generalize well to unforeseen attacks.
+
+# 2 A SET OF DIVERSE AND NOVEL ADVERSARIAL ATTACKS
+
+We consider distortions (attacks) applied to an image $x \in \mathbb { R } ^ { 3 \times 2 2 4 \times 2 2 4 }$ , represented as a vector of RGB values. Let $f : \mathbb { R } ^ { 3 \times 2 2 4 \times 2 2 4 } \stackrel { \bullet \star } { \to } \mathbb { R } ^ { 1 0 0 }$ ∈ be a model mapping images to logits1, and let $\ell ( f ( x ) , y )$ denote the cross-entropy loss. For an input $x$ with true label $y$ and a target class $y ^ { \prime } \ne y$ , our adversarial attacks attempt to find $x ^ { \prime }$ such that
+
+1. the attacked image $x ^ { \prime }$ is obtained by applying a constrained distortion to $x$ , and   
+2. the loss $\ell ( f ( x ^ { \prime } ) , y ^ { \prime } )$ is minimized (targeted attack).
+
+Adversarial training (Goodfellow et al., 2014) is a strong defense baseline against a fixed attack (Madry et al., 2017; Xie et al., 2018) which updates using an attacked image $x ^ { \prime }$ instead of the clean image $x$ at each training iteration.
+
+We consider 8 attacks: $L _ { \infty }$ (Goodfellow et al., 2014), $L _ { 2 }$ (Szegedy et al., 2013; Carlini & Wagner, 2017), $L _ { 1 }$ (Chen et al., 2018), Elastic (Xiao et al., 2018), JPEG, Fog, Gabor, and Snow. We show sample attacked images in Figure 1 and the corresponding distortions in Figure 2. The JPEG, Fog,
+
+![](images/53126ea378587882c6a6dd9dde71609349f423ef460683bbbded70b29cec4e9c.jpg)  
+Figure 2: Scaled pixel-level differences between original and attacked images for each attack (label “espresso maker”). The $L _ { 1 }$ , $L _ { 2 }$ , and $L _ { \infty }$ norms of the difference are shown after the attack name. Our novel attacks display behavior which is qualitatively different from that of the $L _ { p }$ attacks. Attacked images are shown in Figure 1, and unscaled differences are shown in Figure 9, Appendix B.1.
+
+Gabor, and Snow attacks are new to this paper, and the $L _ { 1 }$ attack uses the Frank-Wolfe algorithm to improve on previous $L _ { 1 }$ attacks. We now describe the attacks, whose distortion sizes are controlled by a parameter $\varepsilon$ . We clamp output pixel values to [0, 255].
+
+Existing attacks. The $L _ { p }$ attacks with $p \in \{ 1 , 2 , \infty \}$ modify an image $x$ to an attacked image $\boldsymbol { x } ^ { \prime } = \boldsymbol { x } + \boldsymbol { \delta }$ . We optimize $\delta$ under the constraint $\| \delta \| _ { p } \leq \varepsilon$ , where $\| \cdot \| _ { p }$ is the $L _ { p }$ -norm on $\mathbb { R } ^ { 3 \times 2 2 4 \times 2 2 4 }$ .
+
+The Elastic attack warps the image by allowing distortions $\begin{array} { r } { \begin{array} { r c l } { x ^ { \prime } } & { = } & { \mathsf { F l o w } ( x , V ) } \end{array} } \end{array}$ , where $V :$ $\{ 1 , . . . , 2 2 4 \} ^ { 2 }  \mathbb { R } ^ { 2 }$ is a vector field on pixel space, and Flow sets the value of pixel $( i , j )$ to the bilinearly interpolated original value at $( i , j ) + V ( i , j )$ . We construct $V$ by smoothing a vector field $W$ by a Gaussian kernel (size $2 5 \times 2 5$ , std. dev. 3 for a $2 2 4 \times 2 2 4$ image) and optimize $W$ under $\| W ( i , j ) \| _ { \infty } \leq \varepsilon$ for all $i , j$ . This differs in details from Xiao et al. (2018) but is similar in spirit.
+
+Novel attacks. As discussed in Shin & Song (2017) for defense, JPEG compression applies a lossy linear transformation JPEG based on the discrete cosine transform to image space, followed by quantization. The JPEG attack imposes the $L _ { \infty }$ -constraint $\| \mathsf { J P E G } ( x ) - \mathsf { J P E G } ( x ^ { \prime } ) \| _ { \infty } \leq \varepsilon$ on the attacked image $x ^ { \prime }$ . We optimize $z = \mathsf { J P E G } ( x ^ { \prime } )$ and apply a right inverse of JPEG to obtain $x ^ { \prime }$ .
+
+Our novel Fog, Gabor, and Snow attacks are adversarial versions of non-adversarial distortions proposed in the literature. Fog and Snow introduce adversarially chosen partial occlusions of the image resembling the effect of mist and snowflakes, respectively; stochastic versions of Fog and Snow appeared in Hendrycks & Dietterich (2019). Gabor superimposes adversarially chosen additive Gabor noise (Lagae et al., 2009) onto the image; a stochastic version appeared in
+
+![](images/5ff0aa838ad34a5b5fa0dc3edbdb19d1c3dcbb0d69aba19d8de22b5bb872a93a.jpg)  
+Figure 3: Snow before and after optimization.
+
+Co et al. (2019). These attacks work by optimizing a set of parameters controlling the distortion over an $L _ { \infty }$ -bounded set. Specifically, values for the diamond-square algorithm, sparse noise, and snowflake brightness (Figure 3) are chosen adversarially for Fog, Gabor, and Snow, respectively.
+
+Optimization. To handle $L _ { \infty }$ and $L _ { 2 }$ constraints, we use randomly-initialized projected gradient descent (PGD), which optimizes the distortion $\delta$ by gradient descent and projection to the $L _ { \infty }$ and $L _ { 2 }$ balls (Madry et al., 2017). For $L _ { 1 }$ constraints, this projection is more difficult, and previous $L _ { 1 }$ attacks resort to heuristics (Chen et al., 2018; Tramer & Boneh, 2019). We use the randomly- \` initialized Frank-Wolfe algorithm (Frank & Wolfe, 1956), which replaces projection by a simpler optimization of a linear function at each step (pseudocode in Appendix B.2).
+
+![](images/916798a6d45f2f7ac8d133393ba07b2aeabd5c72794268ae84bc26c050a0be67.jpg)  
+Figure 4: Accuracies of $L _ { 2 }$ and Elastic attacks at different distortion sizes against a ResNet-50 model adversarially trained against $L _ { 2 }$ at $\varepsilon = 9 6 0 0$ on ImageNet-100. At small distortion sizes, the model appears to defend well against Elastic, but large distortion sizes reveal a lack of transfer.
+
+# 3 MOTIVATION AND DESCRIPTION OF OUR METHODOLOGY
+
+We now propose a method to assess robustness against unforeseen distortions, which relies on evaluating a defense against a diverse set of attacks that were not used when designing the defense. Our method must address the following issues:
+
+• The range of distortion sizes must be wide enough to avoid the misleading behavior in which robustness appears to transfer at low distortion sizes but not at high distortion sizes (Figure 4); • The set of attacks considered must be sufficiently diverse.
+
+We first provide a method to calibrate distortion sizes and then use it to define a summary metric that assesses the robustness of a defense against a specific unforeseen attack. Using this metric, we are able to assess diversity and recommend a set of attacks to evaluate against.
+
+Calibrate distortion size using adversarial training. As shown in Figure 4, the correlation between adversarial robustness against different distortion types may look different for different ranges of distortion sizes. It is therefore critical to evaluate on a wide enough range of distortion size $\varepsilon$ . We choose the minimum and maximum distortion sizes $\varepsilon$ using the following principles; sample images at $\varepsilon _ { \mathrm { { m i n } } }$ and $\varepsilon _ { \mathrm { m a x } }$ are shown in Figure 5b.
+
+1. The minimum distortion size $\varepsilon _ { \mathrm { { m i n } } }$ is the largest $\varepsilon$ for which the adversarial validation accuracy against an adversarially trained model is comparable to that of a model trained and evaluated on unattacked data (for ImageNet-100, within 3 of 87).   
+2. The maximum distortion size $\varepsilon _ { \mathrm { m a x } }$ is the smallest $\varepsilon$ which either (a) yields images which confuse humans when applied against adversarially trained models or (b) reduces accuracy of adversarially trained models (ATA below) to below 25.
+
+In practice, we select $\varepsilon _ { \mathrm { { m i n } } }$ and $\varepsilon _ { \mathrm { m a x } }$ according to these criteria from a sequence of $\varepsilon$ which is geometrically increasing with ratio 2. We choose to evaluate against adversarially trained models because attacking against strong defenses is necessary to produce strong visual distortions (Figure 5a). We introduce the constraint that humans recognize attacked images at $\varepsilon _ { \mathrm { m a x } }$ because we find cases for $L _ { 1 }$ , Fog, and Snow where adversarially trained models maintain non-zero accuracy for distortion sizes producing images incomprehensible to humans. An example for Snow is shown in Figure 5b.
+
+UAR: an adversarial robustness metric. We measure a model’s robustness against a specific distortion type by comparing it to adversarially trained models, which represent an approximate ceiling on performance with prior knowledge of the distortion type. For distortion type $A$ and size $\varepsilon$ , let the Adversarial Training Accuracy $\mathsf { A T A } ( A , \varepsilon )$ be the best adversarial accuracy on the test set that can be achieved by adversarially training a specific architecture (ResNet-50 for ImageNet100, ResNet-56 for CIFAR-10) against $A$ .2 Even when evaluating a defense using an architecture
+
+(a) The $L _ { \infty }$ attack at $\varepsilon = 3 2$ applied to undefended model and models adversarially trained against $L _ { \infty }$ at different distortion sizes. Attacking models trained against larger $\varepsilon$ produces greater visual distortion.
+
+![](images/2c560ffed0c3962581881e9bc255b46c65314acabce0aa4fd9c400a3e18ca1c3.jpg)  
+(b) The JPEG, Gabor, and Snow attacks applied to adversarially trained models at $\varepsilon _ { \mathrm { { m i n } } }$ and $\varepsilon _ { \mathrm { m a x } }$ . Distortions are almost imperceptible at $\varepsilon _ { \mathrm { { m i n } } }$ , but make the image barely recognizable by humans at $\varepsilon _ { \mathrm { m a x } }$ .
+
+Figure 5: Varying distortion size against adversarially trained models reveals full attack strength.
+
+other than ResNet-50 or ResNet-56, we recommend using the ATA values computed with these architectures to allow for uniform comparisons.
+
+Given a set of distortion sizes $\{ \varepsilon _ { 1 } , \ldots , \varepsilon _ { n } \}$ , we propose the summary metric UAR (Unforeseen Attack Robustness) normalizing the accuracy of a model $M$ against adversarial training accuracy:
+
+$$
+\mathsf { U A R } ( A , M ) : = 1 0 0 \cdot \left( \frac { 1 } { n } \sum _ { k = 1 } ^ { n } \mathsf { A c c } ( A , \varepsilon _ { k } , M ) \right) \Bigg / \left( \frac { 1 } { n } \sum _ { k = 1 } ^ { n } \mathsf { A T A } ( A , \varepsilon _ { k } ) \right) .
+$$
+
+Here $\mathsf { A c c } ( A , \varepsilon , M )$ is the accuracy of $M$ against distortions of type $A$ and magnitude $\varepsilon$ . We expect most UAR scores to be lower than 100 against held-out distortion types, as an UAR score greater than 100 means that a defense is outperforming an adversarially trained model on that distortion. The normalizing factor in (1) is required to keep UAR scores roughly comparable between distortions, as different distortions can have different strengths as measured by ATA at the chosen distortion sizes.
+
+Having too many or too few $\varepsilon _ { k }$ values in a certain range may cause an attack to appear artificially strong or weak because the functional relation between distortion size and attack strength (measured by ATA) varies between attacks. To make UAR roughly comparable between distortions, we evaluate at $\varepsilon$ increasing geometrically from $\varepsilon _ { \mathrm { { m i n } } }$ to $\varepsilon _ { \mathrm { m a x } }$ by factors of 2 and take the subset of $\varepsilon$ whose ATA values have minimum $\ell _ { 1 }$ -distance to the ATA values of the $L _ { \infty }$ attack at geometrically increasing $\varepsilon$ .
+
+For example, when calibrating Elastic in Table 1, we start with $\varepsilon _ { \mathrm { m i n } } = 0 . 2 5$ and $\varepsilon _ { \operatorname* { m a x } } = 1 6$ based on our earlier criteria. We then compute the ATAs at the 7 geometrically increasing $\varepsilon$ values $\varepsilon \in$ $\{ 0 . 2 5 , 0 . 5 , 1 , 2 , 4 , 8 , 1 6 \}$ . We consider size-6 subsets of those ATA values, view them as vectors of length 6 in decreasing order, and compute the $\ell _ { 1 }$ -distance between these vectors and the vector for $L _ { \infty }$ shown in the first row of Table 1. Finally, we select the $\varepsilon$ values for Elastic in Table 1 as those corresponding to the size-6 subset with minimum $\ell _ { 1 }$ -distance to the vector for $L _ { \infty }$ .
+
+For our 8 distortion types, we provide reference values of $\mathsf { A T A } ( A , \varepsilon )$ on this calibrated range of 6 distortion sizes on ImageNet-100 (Table 1, $\ S 4 )$ ) and CIFAR-10 (Table 3, Appendix C.3.2). This allows UAR computation for a new defense using 6 adversarial evaluations and no adversarial training, reducing computational cost from $^ { 1 9 2 + }$ to 6 NVIDIA V100 GPU-hours on ImageNet-100.
+
+Evaluate against diverse distortion types. Since robustness against different distortion types may have low or no correlation (Figure 6b), measuring performance on different distortions is important to avoid overfitting to a specific type, especially when a defense is constructed with it in mind (as with adversarial training). Our results in $\ S 4$ demonstrate that choosing appropriate distortion types to evaluate against requires some care, as distortions such as $L _ { 1 }$ , $L _ { 2 }$ , and $L _ { \infty }$ that may seem different can actually have highly correlated scores against defenses (see Figure 6). We instead recommend evaluation against our more diverse attacks, taking the $L _ { \infty }$ , $L _ { 1 }$ , Elastic, Fog, and Snow attacks as a starting point.
+
+Table 1: Calibrated distortion sizes and ATA values for different distortion types on ImageNet-100. ATA values for CIFAR-10 are shown in Table 3 (Appendix C.3.2).   
+
+<table><tr><td>Attack ε1</td><td></td><td>ε2</td><td>ε3</td><td>ε4</td><td>£5</td><td>6</td><td>ATA1</td><td>ATA2</td><td>ATA3</td><td>ATA4</td><td>ATA5</td><td>ATA6</td></tr><tr><td>L</td><td>1</td><td>2</td><td>4</td><td>8</td><td>16</td><td>32</td><td>84.6</td><td>82.1</td><td>76.2</td><td>66.9</td><td>40.1</td><td>12.9</td></tr><tr><td>L2</td><td>150</td><td>300</td><td>600</td><td>1200</td><td>2400</td><td>4800</td><td>85.0</td><td>83.5</td><td>79.6</td><td>72.6</td><td>59.1</td><td>19.9</td></tr><tr><td>L1</td><td>9562.5</td><td>19125</td><td>76500 1530001</td><td></td><td>306000 612000</td><td></td><td>84.4</td><td>82.7</td><td>76.3</td><td>68.9</td><td>56.4</td><td>36.1</td></tr><tr><td>Elastic</td><td>0.250</td><td>0.500</td><td>2</td><td>4</td><td>8</td><td>16</td><td>85.9</td><td>83.2</td><td>78.1</td><td>75.6</td><td>57.0</td><td>22.5</td></tr><tr><td>JPEG</td><td>0.062</td><td>0.125</td><td>0.250</td><td>0.500</td><td>1</td><td>2</td><td>85.0</td><td>83.2</td><td>79.3</td><td>72.8</td><td>34.8</td><td>1.1</td></tr><tr><td>Fog</td><td>128</td><td>256</td><td>512</td><td>2048</td><td>4096</td><td>8192</td><td>85.8</td><td>83.8</td><td>79.0</td><td>68.4</td><td>67.9</td><td>64.7</td></tr><tr><td>Snow</td><td>0.062</td><td>0.125</td><td>0.250</td><td>2</td><td>4</td><td>8</td><td>84.0</td><td>81.1</td><td>77.7</td><td>65.6</td><td>59.5</td><td>41.2</td></tr><tr><td>Gabor</td><td>6.250</td><td>12.500 25</td><td></td><td>400</td><td>800</td><td>1600</td><td>84.0</td><td>79.8</td><td>79.8</td><td>66.2</td><td>44.7</td><td>14.6</td></tr></table>
+
+# 4 UAR REVEALS THE NEED TO EVALUATE AGAINST MORE DIVERSE ATTACKS
+
+We apply our methodology to the 8 attacks in $\ S 2$ using models adversarially trained against these attacks. Our results reveal that evaluating against the commonly used $L _ { p }$ -attacks gives highly correlated information which does not generalize to other unforeseen attacks. Instead, they suggest that evaluating on diverse attacks is necessary and identify a set of 5 attacks with low pairwise robustness transfer which we suggest as a starting point when assessing robustness to unforeseen adversaries.
+
+Dataset and model. We use two datasets: CIFAR-10 and ImageNet-100, the 100-class subset of ImageNet-1K (Deng et al., 2009) containing every $1 0 ^ { \mathrm { t h } }$ class by WordNet ID order. We use ResNet56 for CIFAR-10 and ResNet-50 as implemented in torchvision for ImageNet-100 (He et al., 2016). We give training hyperparameters in Appendix A.
+
+Adversarial training and evaluation procedure. We construct hardened models using adversarial training (Madry et al., 2017). To train against attack $A$ , for each mini-batch of training images, we select a uniform random (incorrect) target class for each image. For maximum distortion size $\varepsilon$ , we apply the targeted attack $A$ to the current model with distortion size $\varepsilon ^ { \prime } \sim \mathrm { U n i f o r m } ( 0 , \varepsilon )$ and update the model with a step of stochastic gradient descent using only the resulting adversarial images (no clean images). The random size scaling improves performance especially against smaller distortions. We use 10 optimization steps for all attacks during training except for Elastic, where we use 30 steps due to its more difficult optimization problem. When PGD is used, we use step size $\varepsilon / \sqrt { \mathrm { s t e p s } }$ , the optimal scaling for non-smooth convex functions (Nemirovski & Yudin, 1978; 1983).
+
+We adversarially train 87 models against the 8 attacks from $\ S 2$ at the distortion sizes described in $\ S 3$ and evaluate them on the ImageNet-100 and CIFAR-10 validation sets against 200-step targeted attacks with uniform random (incorrect) target class. This uses more steps for evaluation than train
+
+![](images/0c5e02ee09998407bebd70a1c73ef4f1cba18d475d47a5d603828630625d98cf.jpg)
+
+(a) UAR scores for adv. trained defenses (rows) against attacks (columns) on ImageNet-100. See Figure 12 for more $\varepsilon$ values and Appendix C.3.2 for CIFAR-10 results.
+
+![](images/4791a8dc6b07f45f5b9a2342974dc3da6bc806f48fe6fcd91da43e96f702927a.jpg)
+
+(b) Correlations between UAR scores in Figure 6a for each attack (rows and columns). Correlation was computed over adversarial defenses in Figure 6a trained without knowledge of the attacks (6 total per pair).
+
+Figure 6: UAR scores demonstrate the need to evaluate against diverse attacks.
+
+ing per best practices (Carlini et al., 2019). We use UAR to analyze the results in the remainder of this section, directing the reader to Figures 10 and 11 (Appendix C.2) for exhaustive results and to Appendix D for checks for robustness to random seed and number of attack steps.
+
+Existing defense and evaluation methods do not generalize to unforeseen attacks. The many low off-diagonal UAR scores in Figure 6a make clear that while adversarial training is a strong baseline against a fixed distortion, it only rarely confers robustness to unforeseen distortions. Notably, we were not able to achieve a high UAR against Fog except by directly adversarially training against it. Despite the general lack of transfer in Figure 6a, the fairly strong transfer between the $L _ { p }$ -attacks is consistent with recent progress in simultaneous robustness to them (Croce & Hein, 2019).
+
+Figure 6b shows correlations between UAR scores of pairs of attacks $A$ and $A ^ { \prime }$ against defenses adversarially trained without knowledge3 of $A$ or $A ^ { \prime }$ . The results demonstrate that defenses trained without knowledge of $L _ { p }$ -attacks have highly correlated UAR scores against the different $L _ { p }$ attacks, but this correlation does not extend to their evaluations against other attacks. This suggests that $L _ { p }$ - evaluations offer limited diversity and may not generalize to other unforeseen attacks.
+
+The $L _ { \infty }$ , $L _ { 1 }$ , Elastic, Fog, and Snow attacks offer greater diversity. Our results on $L _ { p }$ -evaluation suggest that more diverse attack evaluation is necessary for generalization to unforeseen attacks. As the unexpected correlation between UAR scores against the pairs (Fog, Gabor) and $\left( \mathrm { J P E G } , L _ { 1 } \right)$ in Figure 6b demonstrates, even attacks with very different distortions may have correlated behaviors. Considering all attacks in Figure 6 together results in signficantly more diversity, which we suggest for evaluation against unforeseen attacks. We suggest the 5 attacks $( L _ { \infty } , L _ { 1 }$ , Elastic, Fog, and Snow) with low UAR against each other and low correlation between UAR scores as a good starting point.
+
+# 5 JOINT ADVERSARIAL TRAINING: DEFENDING AGAINST TWO DISTORTIONS
+
+A natural idea to improve robustness against unforeseen adversaries is to adversarially train the same model against two different types of distortions simultaneously, with the idea that this will cover a larger portion of the space of distortions. We refer to this as joint adversarial training (Jordan et al., 2019; Tramer & Boneh, 2019). For two attacks \` $A$ and $A ^ { \prime }$ , at each training step, we compute the attacked image under both $A$ and $A ^ { \prime }$ and backpropagate with respect to gradients induced by the image with greater loss. This corresponds to the “max” loss described in Tramer & Boneh (2019).\` We jointly train models for $( L _ { \infty } , L _ { 2 } )$ , $( L _ { \infty } , L _ { 1 } )$ , and $( L _ { \infty }$ , Elastic) using the same setup as before
+
+![](images/625170de299531c3cd1b867a34d1444b71f72f927a58c03e996320eda7d22cf6.jpg)  
+Figure 7: UAR scores for jointly adv. trained defenses (rows) against distortion types (columns).
+
+Transfer for jointly trained models. Figure 7 reports UAR scores for jointly trained models using ResNet-50 on ImageNet-100; full evaluation accuracies are in Figure 19 (Appendix E). Comparing to Figure 6a and Figure 12 (Appendix E), we see that, relative to training against only $L _ { 2 }$ , joint training against $( L _ { \infty } , L _ { 2 } )$ slightly improves robustness against $L _ { 1 }$ without harming robustness against other attacks. In contrast, training against $( L _ { \infty } , L _ { 1 } )$ is worse than either training against $L _ { 1 }$ or $L _ { \infty }$ separately (except at small $\varepsilon$ for $L _ { 1 }$ ). Training against $( L _ { \infty }$ , Elastic) also performs poorly.
+
+Joint training and overfitting. Jointly trained models achieve high training accuracy but poor validation accuracy (Figure 8) that fluctuates substantially for different random seeds (Table 4, Appendix E.2). Figure 8 shows the overfitting behavior for $L _ { \infty }$ , Elastic): $L _ { \infty }$ validation accuracy decreases significantly during training while training accuracy increases. This contrasts with standard adversarial training (Figure 8), where validation accuracy levels off as training accuracy increases.
+
+![](images/58b2deb77fae4ade71fabd80f52f452df16aecef04abe171002af23557964b2e.jpg)  
+Figure 8: Left: train and validation curves for joint training against $L _ { \infty }$ , $\varepsilon = 8$ and Elastic, $\varepsilon = 4$ , Right: train and val curves for standard adversarial training for $L _ { \infty }$ , $\varepsilon = 8$ . The joint validation accuracy of $L _ { \infty }$ decreases as training progresses, indicating overfitting.
+
+Overfitting primarily occurs when training against large distortions. We successfully trained against the $( L _ { \infty } , L _ { 1 } )$ and $( L _ { \infty }$ , Elastic) pairs for small distortion sizes with accuracies comparable to but slightly lower than observed in Figure 11 for training against each attack individually (Figure 18, Appendix E). This agrees with behavior reported by Tramer & Boneh (2019) on CIFAR-10. Our \` intuition is that harder training tasks (more diverse distortion types, larger $\varepsilon$ ) make overfitting more likely. We briefly investigate the relation between overfitting and model capacity in Appendix E.3; validation accuracy appears slightly increased for ResNet-101, but overfitting remains.
+
+# 6 DISCUSSION AND RELATED WORK
+
+We have seen that robustness to one attack provides limited information about robustness to other attacks, and moreover that adversarial training provides limited robustness to unforeseen attacks. These results suggest a need to modify or move beyond adversarial training. While joint adversarial training is one possible alternative, our results show it often leads to overfitting. Even ignoring this, it is not clear that joint training would confer robustness to attacks outside of those trained against.
+
+Evaluating robustness has proven difficult, necessitating detailed study of best practices even for a single fixed attack (Papernot et al., 2017; Athalye et al., 2018). We build on these best practices by showing how to choose and calibrate a diverse set of unforeseen attacks. Our work is a supplement to existing practices, not a replacement–we strongly recommend following the guidelines in Papernot et al. (2017) and Athalye et al. (2018) in addition to our recommendations.
+
+Some caution is necessary when interpreting specific numeric results in our paper. Many previous implementations of adversarial training fell prone to gradient masking (Papernot et al., 2017; Engstrom et al., 2018), with apparently successful training occurring only recently (Madry et al., 2017; Xie et al., 2018). While evaluating with moderately many PGD steps (200) helps guard against this, (Qian & Wegman, 2019) shows that an $L _ { \infty }$ -trained model that appeared robust against $L _ { 2 }$ actually had substantially less robustness when evaluating with $1 0 ^ { 6 }$ PGD steps. If this effect is pervasive, then there may be even less transfer between attacks than our current results suggest.
+
+For evaluating against a fixed attack, DeepFool Moosavi-Dezfooli et al. (2015) and CLEVER Weng et al. (2018) can be seen as existing alternatives to UAR. They work by estimating “empirical robustness”, which is the expected minimum $\varepsilon$ needed to successfully attack an image. However, these apply only to attacks which optimize over an $L _ { p }$ -ball of radius $\varepsilon$ , and CLEVER can be susceptible to gradient masking Goodfellow (2018). In addition, empirical robustness is equivalent to linearly averaging accuracy over $\varepsilon$ , which has smaller dynamic range than the geometric average in UAR.
+
+Our results add to a growing line of evidence that evaluating against a single known attack type provides a misleading picture of the robustness of a model (Sharma & Chen, 2017; Engstrom et al., 2017; Jordan et al., 2019; Tramer & Boneh, 2019; Jacobsen et al., 2019). Going one step further, \` we believe that robustness itself provides only a narrow window into model behavior; in addition to robustness, we should seek to build a diverse toolbox for understanding machine learning models, including visualization (Olah et al., 2018; Zhang & Zhu, 2019), disentanglement of relevant features (Geirhos et al., 2018), and measurement of extrapolation to different datasets (Torralba & Efros, 2011) or the long tail of natural but unusual inputs (Hendrycks et al., 2019). Together, these windows into model behavior can give us a clearer picture of how to make models reliable in the real world.
+
+# REFERENCES
+
+Anish Athalye, Logan Engstrom, Andrew Ilyas, and Kevin Kwok. Synthesizing robust adversarial examples. CoRR, abs/1707.07397, 2017. URL http://arxiv.org/abs/1707.07397.
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.
+
+Tom B. Brown, Dandelion Mane, Aurko Roy, Mart ´ ´ın Abadi, and Justin Gilmer. Adversarial patch. CoRR, abs/1712.09665, 2017. URL http://arxiv.org/abs/1712.09665.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017.
+
+Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian J. Goodfellow, Aleksander Madry, and Alexey Kurakin. On evaluating adversarial robustness. CoRR, abs/1902.06705, 2019. URL http://arxiv.org/abs/1902.06705.
+
+Pin-Yu Chen, Yash Sharma, Huan Zhang, Jinfeng Yi, and Cho-Jui Hsieh. EAD: Elastic-net attacks to deep neural networks via adversarial examples. In Thirty-second AAAI conference on artificial intelligence, 2018.
+
+Kenneth T. Co, Luis Munoz-Gonz ˜ alez, and Emil C. Lupu. Sensitivity of deep convolutional net- ´ works to Gabor noise. CoRR, abs/1906.03455, 2019. URL http://arxiv.org/abs/ 1906.03455.
+
+Francesco Croce and Matthias Hein. Provable robustness against all adversarial $l _ { p }$ -perturbations for $p \geq 1$ . CoRR, abs/1905.11213, 2019. URL http://arxiv.org/abs/1905.11213.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. IEEE, 2009.
+
+Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling CNNs with simple transformations. arXiv preprint arXiv:1712.02779, 2017.
+
+Logan Engstrom, Andrew Ilyas, and Anish Athalye. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint arXiv:1807.10272, 2018.
+
+Nic Ford, Justin Gilmer, Nicolas Carlini, and Dogus Cubuk. Adversarial examples are a natural consequence of test error in noise. arXiv preprint arXiv:1901.10513, 2019.
+
+Marguerite Frank and Philip Wolfe. An algorithm for quadratic programming. Naval research logistics quarterly, 3(1-2):95–110, 1956.
+
+Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and Wieland Brendel. ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. CoRR, abs/1811.12231, 2018. URL http://arxiv.org/ abs/1811.12231.
+
+Ian Goodfellow. Gradient masking causes CLEVER to overestimate adversarial perturbation size. arXiv preprint arXiv:1804.07870, 2018.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An- ´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pp. 630–645. Springer, 2016.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019.
+
+Dan Hendrycks, Kevin Zhao, Steven Basart, Jacob Steinhardt, and Dawn Song. Natural adversarial examples. arXiv preprint arXiv:1907.07174, 2019.
+
+Jrn-Henrik Jacobsen, Jens Behrmannn, Nicholas Carlini, Florian Tramr, and Nicolas Papernot. Exploiting excessive invariance caused by norm-bounded adversarial robustness, 2019.
+
+Matt Jordan, Naren Manoj, Surbhi Goel, and Alexandros G. Dimakis. Quantifying perceptual distortion of adversarial examples. arXiv e-prints, art. arXiv:1902.08265, Feb 2019.
+
+Ares Lagae, Sylvain Lefebvre, George Drettakis, and Philip Dutre. Procedural noise using sparse ´ Gabor convolution. ACM Trans. Graph., 28(3):54:1–54:10, July 2009. ISSN 0730-0301. doi: 10. 1145/1531326.1531360. URL http://doi.acm.org/10.1145/1531326.1531360.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. DeepFool: a simple and accurate method to fool deep neural networks. arXiv preprint arXiv:1511.04599, 2015.
+
+Arkadi Nemirovski and D Yudin. On Cezari’s convergence of the steepest descent method for approximating saddle point of convex-concave functions. In Soviet Math. Dokl, volume 19, pp. 258–269, 1978.
+
+Arkadi Nemirovski and D Yudin. Problem Complexity and Method Efficiency in Optimization. Intersci. Ser. Discrete Math. Wiley, New York, 1983.
+
+Chris Olah, Arvind Satyanarayan, Ian Johnson, Shan Carter, Ludwig Schubert, Katherine Ye, and Alexander Mordvintsev. The building blocks of interpretability. Distill, 2018. doi: 10.23915/ distill.00010. https://distill.pub/2018/building-blocks.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia conference on computer and communications security, pp. 506–519. ACM, 2017.
+
+Haifeng Qian and Mark N. Wegman. $L _ { 2 }$ -nonexpansive neural networks. In International Conference on Learning Representations (ICLR), 2019. URL https://openreview.net/forum? id $=$ ByxGSsR9FQ.
+
+Yash Sharma and Pin-Yu Chen. Attacking the Madry defense model with $L _ { 1 }$ -based adversarial examples. arXiv e-prints, art. arXiv:1710.10733, Oct 2017.
+
+Richard Shin and Dawn Song. JPEG-resistant adversarial images. In NIPS 2017 Workshop on Machine Learning and Computer Security, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Antonio Torralba and Alexei A. Efros. Unbiased look at dataset bias. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2011.
+
+Florian Tramer and Dan Boneh. Adversarial training and robustness for multiple perturbations. \` arXiv e-prints, art. arXiv:1904.13000, Apr 2019.
+
+Igor Vasiljevic, Ayan Chakrabarti, and Gregory Shakhnarovich. Examining the impact of blur on recognition by convolutional networks. CoRR, abs/1611.05760, 2016. URL http://arxiv. org/abs/1611.05760.
+
+Tsui-Wei Weng, Huan Zhang, Pin-Yu Chen, Jinfeng Yi, Dong Su, Yupeng Gao, Cho-Jui Hsieh, and Luca Daniel. Evaluating the robustness of neural networks: An extreme value theory approach. arXiv preprint arXiv:1801.10578, 2018.
+
+Chaowei Xiao, Jun-Yan Zhu, Bo Li, Warren He, Mingyan Liu, and Dawn Song. Spatially transformed adversarial examples. arXiv preprint arXiv:1801.02612, 2018.
+
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. arXiv preprint arXiv:1812.03411, 2018.
+
+Tianyuan Zhang and Zhanxing Zhu. Interpreting adversarially trained convolutional neural networks. In International Conference on Machine Learning (ICML), 2019.
+
+# A TRAINING HYPERPARAMETERS
+
+For ImageNet-100, we trained on machines with 8 NVIDIA V100 GPUs using standard data augmentation He et al. (2016). Following best practices for multi-GPU training Goyal et al. (2017), we ran synchronized SGD for 90 epochs with batch size $3 2 \times 8$ and a learning rate schedule with 5 “warm-up” epochs and a decay at epochs 30, 60, and 80 by a factor of 10. Initial learning rate after warm-up was 0.1, momentum was 0.9, and weight decay was $1 0 ^ { - 4 }$ . For CIFAR-10, we trained on a single NVIDIA V100 GPU for 200 epochs with batch size 32, initial learning rate 0.1, momentum 0.9, and weight decay $1 0 ^ { - 4 }$ . We decayed the learning rate at epochs 100 and 150.
+
+# B FURTHER ATTACK DETAILS
+
+# B.1 FURTHER EXAMPLES OF ATTACKS
+
+We show the images corresponding to the ones in Figure 2, with the exception that they are not scaled. The non-scaled images are shown in Figure 9.
+
+# B.2 $L _ { 1 }$ ATTACK
+
+We chose to use the Frank-Wolfe algorithm for optimizing the $L _ { 1 }$ attack, as Projected Gradient Descent would require projecting onto a truncated $L _ { 1 }$ ball, which is a complicated operation. In contrast, Frank-Wolfe only requires optimizing linear functions $g ^ { \top } x$ over a truncated $L _ { 1 }$ ball; this can be done by sorting coordinates by the magnitude of $g$ and moving the top $k$ coordinates to the boundary of their range (with $k$ chosen by binary search). This is detailed in Algorithm 1.
+
+# C FULL EVALUATION RESULTS
+
+# C.1 $L _ { 1 }$ -JPEG AND $L _ { 2 }$ -JPEG ATTACKS
+
+We will present results with two additional versions of the JPEG attack which impose $L _ { 1 }$ or $L _ { 2 }$ constraints on the attack in JPEG-space instead of the $L _ { \infty }$ constraint discussed in Section 2. To avoid confusion, in this appendix, we denote the original JPEG attack by $L _ { \infty }$ -JPEG and these variants by $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG, respectively. Comparing the $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG attacks in Figure 10,
+
+![](images/4ac5967c0d22dc79a6ede0c106dbea07c0ee35bc92400d42a1b2854bac17752a.jpg)  
+Figure 9: Differences of the attacked images and original image for different attacks (label “espresso maker”). The $L _ { 1 }$ , $L _ { 2 }$ , and $L _ { \infty }$ norms of the difference are shown in parentheses. As shown, our novel attacks display qualitatively different behavior and do not fall under the $L _ { p }$ threat model. These differences are not scaled and are normalized so that no difference corresponds to white.
+
+1: Input: function $f$ , initial input $x \in [ 0 , 1 ] ^ { d }$ , $L _ { 1 }$ radius $\rho$ , number of steps $T$ .   
+2: Output: approximate maximizer $\bar { x }$ of $f$ over the truncated $L _ { 1 }$ ball $\mathring { B _ { 1 } } ( \rho ; x ) \cap [ 0 , 1 ] ^ { d }$ centered   
+at $x$ .   
+3:   
+4: $x ^ { ( 0 ) } \gets \mathrm { R a n d o m I n i t } ( x )$ . Random initialization   
+5: for $t = 1 , \dots , T$ do   
+6: g f (x(t−1)) . Obtain gradient   
+7: for $k = 1 , \ldots , d { \mathrm { } } $ do   
+8: $s _ { k } \gets$ index of the coordinate of $g$ by with $k ^ { \mathrm { { t h } } }$ largest norm   
+9: end for   
+10: $S _ { k } \gets \{ s _ { 1 } , \ldots , s _ { k } \} .$   
+11:   
+12: for $i = 1 , \ldots , d$ do . Compute move to boundary of $[ 0 , 1 ]$ for each coordinate.   
+13: if $g _ { i } > 0$ then   
+14: $b _ { i } \gets 1 - x _ { i }$   
+15: else   
+16: $b _ { i } \gets - x _ { i }$   
+17: end if   
+18: end for   
+19: $\begin{array} { r l } & { M _ { k } \gets \sum _ { i \in S _ { k } } | b _ { i } | } \\ & { k ^ { * } \gets \operatorname* { m a x } \{ k \mid M _ { k } \leq \rho \} } \end{array}$ . Compute $L _ { 1 }$ -perturbation of moving $k$ largest coordinates.   
+20: $\triangleright$ Choose largest $k$ satisfying $L _ { 1 }$ constraint.   
+21: for i = 1, . . . , d do $\triangleright$ Compute $\hat { x }$ maximizing $g ^ { \top } x$ over the $L _ { 1 }$ ball.   
+22: if $i \in S _ { k ^ { * } }$ then   
+23: xˆi ← xi + bi   
+24: else if $i = s _ { k ^ { * } + 1 }$ then   
+25: $\hat { x } _ { i } \gets x _ { i } + ( \rho - M _ { k ^ { * } } ) \operatorname { s i g n } ( g _ { i } )$   
+26: else   
+27: $\hat { x } _ { i } \gets x _ { i }$   
+28: end if   
+29: end for   
+30: $\begin{array} { r } { x ^ { ( t ) }  ( 1 - \frac { 1 } { t } ) x ^ { ( t - 1 ) } + \frac { 1 } { t } \hat { x } } \end{array}$ . Average $\hat { x }$ with previous iterates   
+31: end for   
+32: x¯ x(T)
+
+Algorithm 1 Pseudocode for the Frank-Wolfe algorithm for the $L _ { 1 }$ attack.   
+Table 2: ATA values for $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG on ImageNet-100.   
+
+<table><tr><td>Attack</td><td>E1</td><td>E2</td><td>3</td><td>E4</td><td>5</td><td>6</td><td>ATA1</td><td>ATA2</td><td>ATA3</td><td>ATA4</td><td>ATA5</td><td>ATA6</td></tr><tr><td>L2-JPEG</td><td>8</td><td>16</td><td>32</td><td>64</td><td>128</td><td>256</td><td>84.8</td><td>82.5</td><td>78.9</td><td>72.3</td><td>47.5</td><td>3.4</td></tr><tr><td>L1-JPEG</td><td>256</td><td></td><td>10244096</td><td>16384</td><td>65536</td><td>131072</td><td>84.8</td><td>81.8</td><td>76.2</td><td>67.1</td><td>46.4</td><td>41.8</td></tr></table>
+
+we find that they have extremely similar results, so we omit $L _ { 1 }$ -JPEG in the full analysis for brevity and visibility. Calibration values for these attacks are shown in Table 2.
+
+# C.2 FULL EVALUATION RESULTS AND ANALYSIS FOR IMAGENET-100
+
+We show the full results of all adversarial attacks against all adversarial defenses for ImageNet-100 in Figure 11. As described, the $L _ { p }$ attacks and defenses give highly correlated information on heldout defenses and attacks respectively. Thus, we recommend evaluating on a wide range of distortion types. Full UAR scores are also provided for ImageNet-100 in Figure 12.
+
+We further show selected results in Figure 13. As shown, a wide range of $\varepsilon$ is required to see the full behavior.
+
+![](images/866c62ff7619934861f9400f7e14b3b781a41eb94b70cee2d5971c263865942b.jpg)  
+Figure 10: A comparison of $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG attacks.
+
+![](images/15ed640f6afd9cfaf42a569f89e9649ba332000d32eca1facb3c4af57d24a7cf.jpg)
+
+![](images/f208902da7d75877a22d62981b6b41193b92a5ec6dc3950879f712a5112d524c.jpg)  
+Figure 12: UAR scores (multiplied by 100) for adv. trained defenses (rows) against distortion types (columns) for ImageNet-100.
+
+![](images/8521503b091168c4a6dbf8cb92a07c7ed673d88fd7aacaa4ce1797d67781bbff.jpg)  
+Figure 13: Adversarial accuracies of attacks on adversarially trained models for different distortion sizes on ImageNet-100. For a given attack $\varepsilon$ , the best $\varepsilon ^ { \prime }$ to train against satisfies $\varepsilon ^ { \prime } > \varepsilon$ because the random scaling of $\varepsilon ^ { \prime }$ during adversarial training ensures that a typical distortion during adversarial training has size smaller than $\varepsilon ^ { \prime }$ .
+
+# C.3 FULL EVALUATION RESULTS AND ANALYSIS FOR CIFAR-10
+
+# C.3.1 FULL RESULTS FOR CIFAR10
+
+We show the results of adversarial attacks and defenses for CIFAR-10 in Figure 14. We experienced difficulty training the $L _ { 2 }$ and $L _ { 1 }$ attacks at distortion sizes greater than those shown and have omitted those runs, which we believe may be related to the small size of CIFAR-10 images.
+
+# C.3.2 ATA AND UAR FOR CIFAR-10
+
+The $\varepsilon$ calibration procedure for CIFAR-10 was similar to that used for ImageNet-100. We started with the perceptually small $\varepsilon _ { \mathrm { { m i n } } }$ values in Table 3 and increased $\varepsilon$ geometrically with ratio 2 until adversarial accuracy of an adversarially trained model dropped below 40. Note that this threshold is higher for CIFAR-10 because there are fewer classes. The resulting ATA and UAR values for CIFAR10 are shown in Table 3 and Figure 15. We omitted calibration for the $L _ { 2 }$ -JPEG attack because we chose too small a range of $\varepsilon$ for our initial training experiments, and we plan to address this issue in the future.
+
+Table 3: Calibrated distortion sizes and ATA values for ResNet-56 on CIFAR-10   
+
+<table><tr><td>Attack</td><td>1</td><td>£2</td><td>3</td><td>E4</td><td>ε5</td><td>6</td><td>ATA1</td><td>ATA2</td><td>ATA3</td><td>ATA4</td><td>ATA5</td><td>ATA6</td></tr><tr><td>L8</td><td>1</td><td>2</td><td>4</td><td>8</td><td>16</td><td>32</td><td>91.0</td><td>87.8</td><td>81.6</td><td>71.3</td><td>46.5</td><td>23.1</td></tr><tr><td>L2</td><td>40</td><td>80</td><td>160</td><td>320</td><td>640</td><td>2560</td><td>90.1</td><td>86.4</td><td>79.6</td><td>67.3</td><td>49.9</td><td>17.3</td></tr><tr><td>L1</td><td>195</td><td>390</td><td>780</td><td>1560</td><td></td><td>6240 24960</td><td>92.2</td><td>90.0</td><td>83.2</td><td>73.8</td><td>47.4</td><td>35.3</td></tr><tr><td>L-JPEG 0.03125 0.0625 0.125 0.25</td><td></td><td></td><td></td><td></td><td>0.5</td><td>1</td><td>89.7</td><td>87.0</td><td>83.1</td><td>78.6</td><td>69.7</td><td>35.4</td></tr><tr><td>L1-JPEG</td><td>2</td><td>8</td><td>64</td><td>256</td><td>512</td><td>1024</td><td>91.4</td><td>88.1</td><td>80.2</td><td>68.9</td><td>56.3</td><td>37.7</td></tr><tr><td>Elastic</td><td>0.125</td><td>0.25</td><td>0.5</td><td>1</td><td>2</td><td>8</td><td>87.4</td><td>81.3</td><td>72.1</td><td>58.2</td><td>45.4</td><td>27.8</td></tr></table>
+
+# D ROBUSTNESS OF OUR RESULTS
+
+# D.1 REPLICATION
+
+We replicated our results for the first three rows of Figure 11 with different random seeds to see the variation in our results. As shown in Figure 16, deviations in results are minor.
+
+# D.2 CONVERGENCE
+
+We replicated the results in Figure 11 with 50 instead of 200 steps to see how the results changed based on the number of steps in the attack. As shown in Figure 17, the deviations are minor.
+
+# E FURTHER RESULTS FOR JOINT TRAINING
+
+# E.1 FULL EXPERIMENTAL RESULTS
+
+We show the evaluation accuracies of jointly trained models in Figure 18.
+
+We show all the attacks against the jointly adversarially trained defenses in Figure 19.
+
+# E.2 DEPENDENCE ON RANDOM SEED
+
+In Table 4, we study the dependence of joint adversarial training to random seed. We find that at large distortion sizes, joint training for certain pairs of distortions does not produce consistent results over different random initializations.
+
+Table 4: Train and val accuracies for joint adversarial training at large distortion are dependent on seed. For train and val, $\varepsilon ^ { \prime }$ is chosen uniformly at random between 0 and $\varepsilon$ , and we used 10 steps for $L _ { \infty }$ and $L _ { 1 }$ and 30 steps for elastic. Single adversarial training baselines are also shown.   
+
+<table><tr><td>Training parameters (ResNet-50)</td><td>Loo train</td><td>other train</td><td>Loval</td><td>other val</td></tr><tr><td>Lε=8,Elasticε=4,Seed1</td><td>90</td><td>89</td><td>35</td><td>74</td></tr><tr><td>Lε=8,Elastic ε=4,Seed 2</td><td>89</td><td>90</td><td>47</td><td>44</td></tr><tr><td>Lε=8,Elastic ε=4,Seed 3</td><td>90</td><td>89</td><td>29</td><td>63</td></tr><tr><td>Loε=16,L1ε=612000,Seed1</td><td>86</td><td>87</td><td>22</td><td>16</td></tr><tr><td>Loε=16,L1ε=612000,Seed 2</td><td>88</td><td>87</td><td>16</td><td>24</td></tr><tr><td>Lε=8</td><td>81</td><td>1</td><td>74</td><td>1</td></tr><tr><td>L∞ε=16</td><td>68</td><td>1</td><td>63</td><td>1</td></tr><tr><td>Elastic ε=4</td><td>1</td><td>88</td><td>1</td><td>76</td></tr><tr><td>L1ε= 612000</td><td>1</td><td>75</td><td>1</td><td>59</td></tr></table>
+
+Table 5: Training and validation numbers for ResNet-101 and ResNet-50 for joint training against $L _ { \infty }$ , $\varepsilon = 8$ and elastic, $\varepsilon = 4$ .   
+
+<table><tr><td>Trainingparameters</td><td>L train</td><td>other train</td><td>Looval</td><td>other val</td></tr><tr><td>Lε= 8,Elastic ε = 4,ResNet-50 Seed 1</td><td>90</td><td>89</td><td>35</td><td>74</td></tr><tr><td>Lε= 8,Elastic ε = 4,ResNet-50 Seed 2</td><td>89</td><td>90</td><td>47</td><td>44</td></tr><tr><td>Lε= 8,Elastic ε= 4 ResNet-101</td><td>90</td><td>91</td><td>49</td><td>46</td></tr></table>
+
+# E.3 OVERFITTING AND MODEL CAPACITY
+
+As a first test to understand the relationship between model capacity and overfitting, we trained ResNet-101 models using the same procedure as in Section 5. Briefly, overfitting still occurs, but ResNet-101 achieves a few percentage points higher than ResNet-50.
+
+We show the training curves in Figure 20 and the training and validation numbers in Table 5.
+
+# F COMPARING ADVERSARIAL DISTORTIONS AND COMMON CORRUPTIONS
+
+“Common” visual corruptions such as (non-adversarial) fog, blur, or pixelation have emerged as another avenue for measuring the robustness of computer vision models (Vasiljevic et al., 2016; Hendrycks & Dietterich, 2019; Geirhos et al., 2018). Recent work suggests that robustness to such common corruptions is linked to adversarial robustness and proposes corruption robustness as an easily computed indicator of adversarial robustness (Ford et al., 2019). We consider this alternative to our methodology by testing corruption robustness of our models on the ImageNet-C benchmark.
+
+Experimental setup. We evaluate on the 100-class subset of the corruption robustness benchmark ImageNet-C introduced in (Hendrycks & Dietterich, 2019) with the same classes as ImageNet-100, which we call ImageNet-C-100. It is the ImageNet-100 validation set with 19 common corruptions at 5 severities. We use the JPEG files available at https://github.com/hendrycks/ robustness. We show average accuracies by distortion type in Figure 21.
+
+Adversarial training against small distortions increases corruption robustness. The first column of each block in Figure 21 shows that training against small adversarial distortions generally increases average accuracy compared to an undefended model. However, training against larger distortions often decreases average accuracy, largely due to the resulting decrease in clean accuracy.
+
+Adversarial distortions and common corruptions can affect defenses differently. Our $L _ { p }$ -JPEG and elastic attacks are adversarial versions of the corresponding common corruptions. While training against adversarial JPEG at larger $\varepsilon$ improves robustness against adversarial JPEG attacks (Figure 12 in Appendix C.2), Figure 21 shows that robustness against common JPEG corruptions decreases as we adversarially train against JPEG at larger $\varepsilon$ , though it remains better than for normally trained models. Similarly, adversarial Elastic training at large $\varepsilon$ begins to hurt robustness to its common counterpart. This is likely because common corruptions are easier than adversarial distortions, hence the increased robustness does not make up for the decreased clean accuracy.
+
+# G ATTACKS AGAINST UNDEFENDED MODELS
+
+We show sample images of our attacks against undefended models trained in the normal way in Figure 22.
+
+![](images/b5b8f6b51871c6a0f11fb44cfefdc1dea2a5dd2db4a4d0c28fe23116677a6a26.jpg)
+
+![](images/0c4e73dc2723aa7c3ff293a9a09c0b880a5c6c3f7550840ab4050ca4c424aaac.jpg)  
+Figure 15: UAR scores on CIFAR-10. Displayed UAR scores are multiplied by 100 for clarity.
+
+![](images/65f7ff576df4174255ea289276b086b77df68cad821a354c04d96e086f25d260.jpg)  
+Figure 16: Replica of the first three block rows of Figure 11 with different random seeds. Deviations in results are minor.
+
+![](images/6d1496d4291d97b42becddbf4d3547aa618349688b1e535c348aeaebda6c32e3.jpg)
+
+![](images/ded149cae3872a9d542dd33f0b1c5c0b791035dd74d30e540c63c3cea29598ee.jpg)  
+Figure 18: Evaluation accuracies of jointly trained models. Attack and training $\varepsilon$ values are equal.
+
+![](images/40e99c031d044efe49fd15d28bbe5c484490bfc2d61019c7bed9bf530aa7f0cc.jpg)  
+Figure 19: All attacks (columns) vs. jointly adversarially trained defense (rows).
+
+![](images/a7e7161e19fc6c98cc3b875c7e4cf96613fdeb7b1a7e9ce0a6a179944c8a7ed9.jpg)  
+Figure 20: Train and validation curves for joint training against $L _ { \infty }$ , $\varepsilon = 4$ and elastic, $\varepsilon = 8$ using ResNet-101. As shown, the validation accuracies decrease as training progresses, indicating overfitting.
+
+![](images/aed8ae41d6c19ccf263818714ff2666fa1ad3c9fff93218a083dd2377626c5ac.jpg)  
+Figure 21: Accuracies of defenses (rows) on ImageNet-C-100 corruptions (columns).
+
+![](images/ba71eedb6d42fa3e008d3220da4fc4756004f0e059682f5d6fef415a5e30e90e.jpg)  
+Figure 22: Adversarial attacks at low distortion sizes $\varepsilon$ against an undefended model. The pair of (ε, accuracy) is shown after the attack name. Visual differences between the original and attacked images are imperceptible for $L _ { \infty }$ , $L _ { 2 }$ , and JPEG, minor for $L _ { 1 }$ , Elastic, and Gabor, and weatherrelated for Fog and Snow.

parse/train/Hyl5V0EYvB/Hyl5V0EYvB_content_list.json

@@ -0,0 +1,2109 @@
+[
+    {
+        "type": "text",
+        "text": "TESTING ROBUSTNESS AGAINST UNFORESEEN ADVERSARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            566,
+            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": "Most existing defenses against adversarial attacks only consider robustness to $L _ { p }$ - bounded distortions. In reality, the specific attack is rarely known in advance and adversaries are free to modify images in ways which lie outside any fixed distortion model; for example, image rotations lie outside the set of $L _ { p }$ -bounded distortions. In this work, we advocate measuring robustness against a much broader range of unforeseen attacks, attacks whose precise form is unknown during defense design. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            366
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose several new attacks and a methodology for evaluating a defense against a diverse range of unforeseen distortions. First, we construct novel adversarial JPEG, Fog, Gabor, and Snow distortions to simulate more diverse adversaries. We then introduce UAR, a summary metric that measures the robustness of a defense against a given distortion. Using UAR to assess robustness against existing and novel attacks, we perform an extensive study of adversarial robustness. We find that evaluation against existing $L _ { p }$ attacks yields redundant information which does not generalize to other attacks; we instead recommend evaluating against our significantly more diverse set of attacks. We further find that adversarial training against either one or multiple distortions fails to confer robustness to attacks with other distortion types. These results underscore the need to evaluate and study robustness against unforeseen distortions. ",
+        "bbox": [
+            233,
+            368,
+            764,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            564,
+            336,
+            579
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks perform well on many benchmark tasks (He et al., 2016) yet can be fooled by adversarial examples (Goodfellow et al., 2014) or inputs designed to subvert a given model. Adversaries are usually assumed to be constrained by an $L _ { \\infty }$ budget (Goodfellow et al., 2014; Madry et al., 2017; Xie et al., 2018), while other modifications such as adversarial geometric transformations, patches, and even 3D-printed objects have also been considered (Engstrom et al., 2017; Brown et al., 2017; Athalye et al., 2017). However, most work on adversarial robustness assumes that the adversary is fixed and known in advance. Defenses against adversarial attacks are often constructed in view of this specific assumption (Madry et al., 2017). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In practice, adversaries can modify and adapt their attacks so that they are unforeseen. In this work, we propose novel attacks which enable the diverse assessment of robustness to unforeseen attacks. Our attacks are varied ( 2) and qualitatively distinct from current attacks. We propose adversarial JPEG, Fog, Gabor, and Snow attacks (sample images in Figure 1). ",
+        "bbox": [
+            176,
+            714,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose an unforeseen attack evaluation methodology (§3) that involves evaluating a defense against a diverse set of held-out distortions decoupled from the defense design. For a fixed, held-out distortion, we then evaluate the defense against the distortion for a calibrated range of distortion sizes whose strength is roughly comparable across distortions. For each fixed distortion, we summarize the robustness of a defense against that distortion relative to a model adversarially trained on that distortion, a measure we call UAR. We provide code and calibrations to easily evaluate a defense against our suite of attacks at https://github.com/iclr-2020-submission/ advex-uar. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "By applying our method to 87 adversarially trained models and 8 different distortion types (§4), we find that existing defenses and evaluation practices have marked weaknesses. Our results show that existing defenses based on adversarial training do not generalize to unforeseen adversaries, even when restricted to the 8 distortions in Figure 1. This adds to the mounting evidence that achieving robustness against a single distortion type is insufficient to impart robustness to unforeseen attacks (Jacobsen et al., 2019; Jordan et al., 2019; Tramer & Boneh, 2019). \\` ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae27e0b408151854ee1ac8545b5497c78e3d2093b17b785048cead2dcca9a7af.jpg",
+        "image_caption": [
+            "Figure 1: Attacked images (label “espresso maker”) against adversarially trained models with large $\\varepsilon$ . Each of the adversarial images above are optimized to maximize the classification loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            107,
+            790,
+            343
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            397,
+            825,
+            454
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Turning to evaluation, our results demonstrate that accuracy against different $L _ { p }$ distortions is highly correlated relative to the other distortions we consider. This suggest that the common practice of evaluating only against $L _ { p }$ distortions to test a model’s adversarial robustness can give a misleading account. Our analysis demonstrates that our full suite of attacks adds substantive attack diversity and gives a more complete picture of a model’s robustness to unforeseen attacks. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            531
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A natural approach is to defend against multiple distortion types simultaneously in the hope that seeing a larger space of distortions provides greater transfer to unforeseen distortions. Unfortunately, we find that defending against even two different distortion types via joint adversarial training is difficult (§5). Specifically, joint adversarial training leads to overfitting at moderate distortion sizes. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            593
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we propose a metric UAR to assess robustness of defenses against unforeseen adversaries. We introduce a total of 4 novel attacks. We apply UAR to assess how robustness transfers to existing attacks and our novel attacks. Our results demonstrate that existing defense and evaluation methods do not generalize well to unforeseen attacks. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 A SET OF DIVERSE AND NOVEL ADVERSARIAL ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            678,
+            669,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider distortions (attacks) applied to an image $x \\in \\mathbb { R } ^ { 3 \\times 2 2 4 \\times 2 2 4 }$ , represented as a vector of RGB values. Let $f : \\mathbb { R } ^ { 3 \\times 2 2 4 \\times 2 2 4 } \\stackrel { \\bullet \\star } { \\to } \\mathbb { R } ^ { 1 0 0 }$ ∈ be a model mapping images to logits1, and let $\\ell ( f ( x ) , y )$ denote the cross-entropy loss. For an input $x$ with true label $y$ and a target class $y ^ { \\prime } \\ne y$ , our adversarial attacks attempt to find $x ^ { \\prime }$ such that ",
+        "bbox": [
+            174,
+            707,
+            826,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. the attacked image $x ^ { \\prime }$ is obtained by applying a constrained distortion to $x$ , and   \n2. the loss $\\ell ( f ( x ^ { \\prime } ) , y ^ { \\prime } )$ is minimized (targeted attack). ",
+        "bbox": [
+            209,
+            770,
+            751,
+            803
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training (Goodfellow et al., 2014) is a strong defense baseline against a fixed attack (Madry et al., 2017; Xie et al., 2018) which updates using an attacked image $x ^ { \\prime }$ instead of the clean image $x$ at each training iteration. ",
+        "bbox": [
+            176,
+            809,
+            825,
+            851
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider 8 attacks: $L _ { \\infty }$ (Goodfellow et al., 2014), $L _ { 2 }$ (Szegedy et al., 2013; Carlini & Wagner, 2017), $L _ { 1 }$ (Chen et al., 2018), Elastic (Xiao et al., 2018), JPEG, Fog, Gabor, and Snow. We show sample attacked images in Figure 1 and the corresponding distortions in Figure 2. The JPEG, Fog, ",
+        "bbox": [
+            176,
+            857,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/53126ea378587882c6a6dd9dde71609349f423ef460683bbbded70b29cec4e9c.jpg",
+        "image_caption": [
+            "Figure 2: Scaled pixel-level differences between original and attacked images for each attack (label “espresso maker”). The $L _ { 1 }$ , $L _ { 2 }$ , and $L _ { \\infty }$ norms of the difference are shown after the attack name. Our novel attacks display behavior which is qualitatively different from that of the $L _ { p }$ attacks. Attacked images are shown in Figure 1, and unscaled differences are shown in Figure 9, Appendix B.1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            106,
+            815,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gabor, and Snow attacks are new to this paper, and the $L _ { 1 }$ attack uses the Frank-Wolfe algorithm to improve on previous $L _ { 1 }$ attacks. We now describe the attacks, whose distortion sizes are controlled by a parameter $\\varepsilon$ . We clamp output pixel values to [0, 255]. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Existing attacks. The $L _ { p }$ attacks with $p \\in \\{ 1 , 2 , \\infty \\}$ modify an image $x$ to an attacked image $\\boldsymbol { x } ^ { \\prime } = \\boldsymbol { x } + \\boldsymbol { \\delta }$ . We optimize $\\delta$ under the constraint $\\| \\delta \\| _ { p } \\leq \\varepsilon$ , where $\\| \\cdot \\| _ { p }$ is the $L _ { p }$ -norm on $\\mathbb { R } ^ { 3 \\times 2 2 4 \\times 2 2 4 }$ . ",
+        "bbox": [
+            173,
+            497,
+            823,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Elastic attack warps the image by allowing distortions $\\begin{array} { r } { \\begin{array} { r c l } { x ^ { \\prime } } & { = } & { \\mathsf { F l o w } ( x , V ) } \\end{array} } \\end{array}$ , where $V :$ $\\{ 1 , . . . , 2 2 4 \\} ^ { 2 }  \\mathbb { R } ^ { 2 }$ is a vector field on pixel space, and Flow sets the value of pixel $( i , j )$ to the bilinearly interpolated original value at $( i , j ) + V ( i , j )$ . We construct $V$ by smoothing a vector field $W$ by a Gaussian kernel (size $2 5 \\times 2 5$ , std. dev. 3 for a $2 2 4 \\times 2 2 4$ image) and optimize $W$ under $\\| W ( i , j ) \\| _ { \\infty } \\leq \\varepsilon$ for all $i , j$ . This differs in details from Xiao et al. (2018) but is similar in spirit. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Novel attacks. As discussed in Shin & Song (2017) for defense, JPEG compression applies a lossy linear transformation JPEG based on the discrete cosine transform to image space, followed by quantization. The JPEG attack imposes the $L _ { \\infty }$ -constraint $\\| \\mathsf { J P E G } ( x ) - \\mathsf { J P E G } ( x ^ { \\prime } ) \\| _ { \\infty } \\leq \\varepsilon$ on the attacked image $x ^ { \\prime }$ . We optimize $z = \\mathsf { J P E G } ( x ^ { \\prime } )$ and apply a right inverse of JPEG to obtain $x ^ { \\prime }$ . ",
+        "bbox": [
+            173,
+            613,
+            825,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our novel Fog, Gabor, and Snow attacks are adversarial versions of non-adversarial distortions proposed in the literature. Fog and Snow introduce adversarially chosen partial occlusions of the image resembling the effect of mist and snowflakes, respectively; stochastic versions of Fog and Snow appeared in Hendrycks & Dietterich (2019). Gabor superimposes adversarially chosen additive Gabor noise (Lagae et al., 2009) onto the image; a stochastic version appeared in ",
+        "bbox": [
+            174,
+            678,
+            490,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ff0aa838ad34a5b5fa0dc3edbdb19d1c3dcbb0d69aba19d8de22b5bb872a93a.jpg",
+        "image_caption": [
+            "Figure 3: Snow before and after optimization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            680,
+            821,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Co et al. (2019). These attacks work by optimizing a set of parameters controlling the distortion over an $L _ { \\infty }$ -bounded set. Specifically, values for the diamond-square algorithm, sparse noise, and snowflake brightness (Figure 3) are chosen adversarially for Fog, Gabor, and Snow, respectively. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            858
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimization. To handle $L _ { \\infty }$ and $L _ { 2 }$ constraints, we use randomly-initialized projected gradient descent (PGD), which optimizes the distortion $\\delta$ by gradient descent and projection to the $L _ { \\infty }$ and $L _ { 2 }$ balls (Madry et al., 2017). For $L _ { 1 }$ constraints, this projection is more difficult, and previous $L _ { 1 }$ attacks resort to heuristics (Chen et al., 2018; Tramer & Boneh, 2019). We use the randomly- \\` initialized Frank-Wolfe algorithm (Frank & Wolfe, 1956), which replaces projection by a simpler optimization of a linear function at each step (pseudocode in Appendix B.2). ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/916798a6d45f2f7ac8d133393ba07b2aeabd5c72794268ae84bc26c050a0be67.jpg",
+        "image_caption": [
+            "Figure 4: Accuracies of $L _ { 2 }$ and Elastic attacks at different distortion sizes against a ResNet-50 model adversarially trained against $L _ { 2 }$ at $\\varepsilon = 9 6 0 0$ on ImageNet-100. At small distortion sizes, the model appears to defend well against Elastic, but large distortion sizes reveal a lack of transfer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            812,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            299,
+            823,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 MOTIVATION AND DESCRIPTION OF OUR METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            678,
+            364
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now propose a method to assess robustness against unforeseen distortions, which relies on evaluating a defense against a diverse set of attacks that were not used when designing the defense. Our method must address the following issues: ",
+        "bbox": [
+            178,
+            378,
+            823,
+            421
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• The range of distortion sizes must be wide enough to avoid the misleading behavior in which robustness appears to transfer at low distortion sizes but not at high distortion sizes (Figure 4); • The set of attacks considered must be sufficiently diverse. ",
+        "bbox": [
+            187,
+            429,
+            823,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first provide a method to calibrate distortion sizes and then use it to define a summary metric that assesses the robustness of a defense against a specific unforeseen attack. Using this metric, we are able to assess diversity and recommend a set of attacks to evaluate against. ",
+        "bbox": [
+            178,
+            479,
+            821,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Calibrate distortion size using adversarial training. As shown in Figure 4, the correlation between adversarial robustness against different distortion types may look different for different ranges of distortion sizes. It is therefore critical to evaluate on a wide enough range of distortion size $\\varepsilon$ . We choose the minimum and maximum distortion sizes $\\varepsilon$ using the following principles; sample images at $\\varepsilon _ { \\mathrm { { m i n } } }$ and $\\varepsilon _ { \\mathrm { m a x } }$ are shown in Figure 5b. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. The minimum distortion size $\\varepsilon _ { \\mathrm { { m i n } } }$ is the largest $\\varepsilon$ for which the adversarial validation accuracy against an adversarially trained model is comparable to that of a model trained and evaluated on unattacked data (for ImageNet-100, within 3 of 87).   \n2. The maximum distortion size $\\varepsilon _ { \\mathrm { m a x } }$ is the smallest $\\varepsilon$ which either (a) yields images which confuse humans when applied against adversarially trained models or (b) reduces accuracy of adversarially trained models (ATA below) to below 25. ",
+        "bbox": [
+            212,
+            613,
+            825,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In practice, we select $\\varepsilon _ { \\mathrm { { m i n } } }$ and $\\varepsilon _ { \\mathrm { m a x } }$ according to these criteria from a sequence of $\\varepsilon$ which is geometrically increasing with ratio 2. We choose to evaluate against adversarially trained models because attacking against strong defenses is necessary to produce strong visual distortions (Figure 5a). We introduce the constraint that humans recognize attacked images at $\\varepsilon _ { \\mathrm { m a x } }$ because we find cases for $L _ { 1 }$ , Fog, and Snow where adversarially trained models maintain non-zero accuracy for distortion sizes producing images incomprehensible to humans. An example for Snow is shown in Figure 5b. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "UAR: an adversarial robustness metric. We measure a model’s robustness against a specific distortion type by comparing it to adversarially trained models, which represent an approximate ceiling on performance with prior knowledge of the distortion type. For distortion type $A$ and size $\\varepsilon$ , let the Adversarial Training Accuracy $\\mathsf { A T A } ( A , \\varepsilon )$ be the best adversarial accuracy on the test set that can be achieved by adversarially training a specific architecture (ResNet-50 for ImageNet100, ResNet-56 for CIFAR-10) against $A$ .2 Even when evaluating a defense using an architecture ",
+        "bbox": [
+            173,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(a) The $L _ { \\infty }$ attack at $\\varepsilon = 3 2$ applied to undefended model and models adversarially trained against $L _ { \\infty }$ at different distortion sizes. Attacking models trained against larger $\\varepsilon$ produces greater visual distortion. ",
+        "bbox": [
+            173,
+            285,
+            486,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c560ffed0c3962581881e9bc255b46c65314acabce0aa4fd9c400a3e18ca1c3.jpg",
+        "image_caption": [
+            "(b) The JPEG, Gabor, and Snow attacks applied to adversarially trained models at $\\varepsilon _ { \\mathrm { { m i n } } }$ and $\\varepsilon _ { \\mathrm { m a x } }$ . Distortions are almost imperceptible at $\\varepsilon _ { \\mathrm { { m i n } } }$ , but make the image barely recognizable by humans at $\\varepsilon _ { \\mathrm { m a x } }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            828,
+            277
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 5: Varying distortion size against adversarially trained models reveals full attack strength. ",
+        "bbox": [
+            178,
+            347,
+            813,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "other than ResNet-50 or ResNet-56, we recommend using the ATA values computed with these architectures to allow for uniform comparisons. ",
+        "bbox": [
+            174,
+            382,
+            820,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a set of distortion sizes $\\{ \\varepsilon _ { 1 } , \\ldots , \\varepsilon _ { n } \\}$ , we propose the summary metric UAR (Unforeseen Attack Robustness) normalizing the accuracy of a model $M$ against adversarial training accuracy: ",
+        "bbox": [
+            173,
+            417,
+            823,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2bd0ab5ae2a993f6849835924ece22283669f58bf372d568fbb85a62c331e273.jpg",
+        "text": "$$\n\\mathsf { U A R } ( A , M ) : = 1 0 0 \\cdot \\left( \\frac { 1 } { n } \\sum _ { k = 1 } ^ { n } \\mathsf { A c c } ( A , \\varepsilon _ { k } , M ) \\right) \\Bigg / \\left( \\frac { 1 } { n } \\sum _ { k = 1 } ^ { n } \\mathsf { A T A } ( A , \\varepsilon _ { k } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            452,
+            745,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathsf { A c c } ( A , \\varepsilon , M )$ is the accuracy of $M$ against distortions of type $A$ and magnitude $\\varepsilon$ . We expect most UAR scores to be lower than 100 against held-out distortion types, as an UAR score greater than 100 means that a defense is outperforming an adversarially trained model on that distortion. The normalizing factor in (1) is required to keep UAR scores roughly comparable between distortions, as different distortions can have different strengths as measured by ATA at the chosen distortion sizes. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            573
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Having too many or too few $\\varepsilon _ { k }$ values in a certain range may cause an attack to appear artificially strong or weak because the functional relation between distortion size and attack strength (measured by ATA) varies between attacks. To make UAR roughly comparable between distortions, we evaluate at $\\varepsilon$ increasing geometrically from $\\varepsilon _ { \\mathrm { { m i n } } }$ to $\\varepsilon _ { \\mathrm { m a x } }$ by factors of 2 and take the subset of $\\varepsilon$ whose ATA values have minimum $\\ell _ { 1 }$ -distance to the ATA values of the $L _ { \\infty }$ attack at geometrically increasing $\\varepsilon$ . ",
+        "bbox": [
+            174,
+            579,
+            825,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For example, when calibrating Elastic in Table 1, we start with $\\varepsilon _ { \\mathrm { m i n } } = 0 . 2 5$ and $\\varepsilon _ { \\operatorname* { m a x } } = 1 6$ based on our earlier criteria. We then compute the ATAs at the 7 geometrically increasing $\\varepsilon$ values $\\varepsilon \\in$ $\\{ 0 . 2 5 , 0 . 5 , 1 , 2 , 4 , 8 , 1 6 \\}$ . We consider size-6 subsets of those ATA values, view them as vectors of length 6 in decreasing order, and compute the $\\ell _ { 1 }$ -distance between these vectors and the vector for $L _ { \\infty }$ shown in the first row of Table 1. Finally, we select the $\\varepsilon$ values for Elastic in Table 1 as those corresponding to the size-6 subset with minimum $\\ell _ { 1 }$ -distance to the vector for $L _ { \\infty }$ . ",
+        "bbox": [
+            174,
+            655,
+            825,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For our 8 distortion types, we provide reference values of $\\mathsf { A T A } ( A , \\varepsilon )$ on this calibrated range of 6 distortion sizes on ImageNet-100 (Table 1, $\\ S 4 )$ ) and CIFAR-10 (Table 3, Appendix C.3.2). This allows UAR computation for a new defense using 6 adversarial evaluations and no adversarial training, reducing computational cost from $^ { 1 9 2 + }$ to 6 NVIDIA V100 GPU-hours on ImageNet-100. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            803
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Evaluate against diverse distortion types. Since robustness against different distortion types may have low or no correlation (Figure 6b), measuring performance on different distortions is important to avoid overfitting to a specific type, especially when a defense is constructed with it in mind (as with adversarial training). Our results in $\\ S 4$ demonstrate that choosing appropriate distortion types to evaluate against requires some care, as distortions such as $L _ { 1 }$ , $L _ { 2 }$ , and $L _ { \\infty }$ that may seem different can actually have highly correlated scores against defenses (see Figure 6). We instead recommend evaluation against our more diverse attacks, taking the $L _ { \\infty }$ , $L _ { 1 }$ , Elastic, Fog, and Snow attacks as a starting point. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/921d31078c34df984403605dc8ddaaaa16e37182faed94bcec1860b719ab71ad.jpg",
+        "table_caption": [
+            "Table 1: Calibrated distortion sizes and ATA values for different distortion types on ImageNet-100. ATA values for CIFAR-10 are shown in Table 3 (Appendix C.3.2). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack ε1</td><td></td><td>ε2</td><td>ε3</td><td>ε4</td><td>£5</td><td>6</td><td>ATA1</td><td>ATA2</td><td>ATA3</td><td>ATA4</td><td>ATA5</td><td>ATA6</td></tr><tr><td>L</td><td>1</td><td>2</td><td>4</td><td>8</td><td>16</td><td>32</td><td>84.6</td><td>82.1</td><td>76.2</td><td>66.9</td><td>40.1</td><td>12.9</td></tr><tr><td>L2</td><td>150</td><td>300</td><td>600</td><td>1200</td><td>2400</td><td>4800</td><td>85.0</td><td>83.5</td><td>79.6</td><td>72.6</td><td>59.1</td><td>19.9</td></tr><tr><td>L1</td><td>9562.5</td><td>19125</td><td>76500 1530001</td><td></td><td>306000 612000</td><td></td><td>84.4</td><td>82.7</td><td>76.3</td><td>68.9</td><td>56.4</td><td>36.1</td></tr><tr><td>Elastic</td><td>0.250</td><td>0.500</td><td>2</td><td>4</td><td>8</td><td>16</td><td>85.9</td><td>83.2</td><td>78.1</td><td>75.6</td><td>57.0</td><td>22.5</td></tr><tr><td>JPEG</td><td>0.062</td><td>0.125</td><td>0.250</td><td>0.500</td><td>1</td><td>2</td><td>85.0</td><td>83.2</td><td>79.3</td><td>72.8</td><td>34.8</td><td>1.1</td></tr><tr><td>Fog</td><td>128</td><td>256</td><td>512</td><td>2048</td><td>4096</td><td>8192</td><td>85.8</td><td>83.8</td><td>79.0</td><td>68.4</td><td>67.9</td><td>64.7</td></tr><tr><td>Snow</td><td>0.062</td><td>0.125</td><td>0.250</td><td>2</td><td>4</td><td>8</td><td>84.0</td><td>81.1</td><td>77.7</td><td>65.6</td><td>59.5</td><td>41.2</td></tr><tr><td>Gabor</td><td>6.250</td><td>12.500 25</td><td></td><td>400</td><td>800</td><td>1600</td><td>84.0</td><td>79.8</td><td>79.8</td><td>66.2</td><td>44.7</td><td>14.6</td></tr></table>",
+        "bbox": [
+            209,
+            141,
+            789,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 UAR REVEALS THE NEED TO EVALUATE AGAINST MORE DIVERSE ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            291,
+            821,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We apply our methodology to the 8 attacks in $\\ S 2$ using models adversarially trained against these attacks. Our results reveal that evaluating against the commonly used $L _ { p }$ -attacks gives highly correlated information which does not generalize to other unforeseen attacks. Instead, they suggest that evaluating on diverse attacks is necessary and identify a set of 5 attacks with low pairwise robustness transfer which we suggest as a starting point when assessing robustness to unforeseen adversaries. ",
+        "bbox": [
+            174,
+            323,
+            825,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset and model. We use two datasets: CIFAR-10 and ImageNet-100, the 100-class subset of ImageNet-1K (Deng et al., 2009) containing every $1 0 ^ { \\mathrm { t h } }$ class by WordNet ID order. We use ResNet56 for CIFAR-10 and ResNet-50 as implemented in torchvision for ImageNet-100 (He et al., 2016). We give training hyperparameters in Appendix A. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training and evaluation procedure. We construct hardened models using adversarial training (Madry et al., 2017). To train against attack $A$ , for each mini-batch of training images, we select a uniform random (incorrect) target class for each image. For maximum distortion size $\\varepsilon$ , we apply the targeted attack $A$ to the current model with distortion size $\\varepsilon ^ { \\prime } \\sim \\mathrm { U n i f o r m } ( 0 , \\varepsilon )$ and update the model with a step of stochastic gradient descent using only the resulting adversarial images (no clean images). The random size scaling improves performance especially against smaller distortions. We use 10 optimization steps for all attacks during training except for Elastic, where we use 30 steps due to its more difficult optimization problem. When PGD is used, we use step size $\\varepsilon / \\sqrt { \\mathrm { s t e p s } }$ , the optimal scaling for non-smooth convex functions (Nemirovski & Yudin, 1978; 1983). ",
+        "bbox": [
+            173,
+            469,
+            825,
+            595
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We adversarially train 87 models against the 8 attacks from $\\ S 2$ at the distortion sizes described in $\\ S 3$ and evaluate them on the ImageNet-100 and CIFAR-10 validation sets against 200-step targeted attacks with uniform random (incorrect) target class. This uses more steps for evaluation than train",
+        "bbox": [
+            174,
+            602,
+            825,
+            645
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c5e02ee09998407bebd70a1c73ef4f1cba18d475d47a5d603828630625d98cf.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            679,
+            442,
+            854
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(a) UAR scores for adv. trained defenses (rows) against attacks (columns) on ImageNet-100. See Figure 12 for more $\\varepsilon$ values and Appendix C.3.2 for CIFAR-10 results. ",
+        "bbox": [
+            173,
+            856,
+            468,
+            906
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4791a8dc6b07f45f5b9a2342974dc3da6bc806f48fe6fcd91da43e96f702927a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            675,
+            797,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(b) Correlations between UAR scores in Figure 6a for each attack (rows and columns). Correlation was computed over adversarial defenses in Figure 6a trained without knowledge of the attacks (6 total per pair). ",
+        "bbox": [
+            488,
+            854,
+            820,
+            905
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 6: UAR scores demonstrate the need to evaluate against diverse attacks. ",
+        "bbox": [
+            243,
+            911,
+            756,
+            926
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ing per best practices (Carlini et al., 2019). We use UAR to analyze the results in the remainder of this section, directing the reader to Figures 10 and 11 (Appendix C.2) for exhaustive results and to Appendix D for checks for robustness to random seed and number of attack steps. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Existing defense and evaluation methods do not generalize to unforeseen attacks. The many low off-diagonal UAR scores in Figure 6a make clear that while adversarial training is a strong baseline against a fixed distortion, it only rarely confers robustness to unforeseen distortions. Notably, we were not able to achieve a high UAR against Fog except by directly adversarially training against it. Despite the general lack of transfer in Figure 6a, the fairly strong transfer between the $L _ { p }$ -attacks is consistent with recent progress in simultaneous robustness to them (Croce & Hein, 2019). ",
+        "bbox": [
+            174,
+            156,
+            823,
+            239
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 6b shows correlations between UAR scores of pairs of attacks $A$ and $A ^ { \\prime }$ against defenses adversarially trained without knowledge3 of $A$ or $A ^ { \\prime }$ . The results demonstrate that defenses trained without knowledge of $L _ { p }$ -attacks have highly correlated UAR scores against the different $L _ { p }$ attacks, but this correlation does not extend to their evaluations against other attacks. This suggests that $L _ { p }$ - evaluations offer limited diversity and may not generalize to other unforeseen attacks. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            316
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The $L _ { \\infty }$ , $L _ { 1 }$ , Elastic, Fog, and Snow attacks offer greater diversity. Our results on $L _ { p }$ -evaluation suggest that more diverse attack evaluation is necessary for generalization to unforeseen attacks. As the unexpected correlation between UAR scores against the pairs (Fog, Gabor) and $\\left( \\mathrm { J P E G } , L _ { 1 } \\right)$ in Figure 6b demonstrates, even attacks with very different distortions may have correlated behaviors. Considering all attacks in Figure 6 together results in signficantly more diversity, which we suggest for evaluation against unforeseen attacks. We suggest the 5 attacks $( L _ { \\infty } , L _ { 1 }$ , Elastic, Fog, and Snow) with low UAR against each other and low correlation between UAR scores as a good starting point. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            424
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 JOINT ADVERSARIAL TRAINING: DEFENDING AGAINST TWO DISTORTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            445,
+            818,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A natural idea to improve robustness against unforeseen adversaries is to adversarially train the same model against two different types of distortions simultaneously, with the idea that this will cover a larger portion of the space of distortions. We refer to this as joint adversarial training (Jordan et al., 2019; Tramer & Boneh, 2019). For two attacks \\` $A$ and $A ^ { \\prime }$ , at each training step, we compute the attacked image under both $A$ and $A ^ { \\prime }$ and backpropagate with respect to gradients induced by the image with greater loss. This corresponds to the “max” loss described in Tramer & Boneh (2019).\\` We jointly train models for $( L _ { \\infty } , L _ { 2 } )$ , $( L _ { \\infty } , L _ { 1 } )$ , and $( L _ { \\infty }$ , Elastic) using the same setup as before ",
+        "bbox": [
+            173,
+            476,
+            825,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/625170de299531c3cd1b867a34d1444b71f72f927a58c03e996320eda7d22cf6.jpg",
+        "image_caption": [
+            "Figure 7: UAR scores for jointly adv. trained defenses (rows) against distortion types (columns). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            593,
+            810,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Transfer for jointly trained models. Figure 7 reports UAR scores for jointly trained models using ResNet-50 on ImageNet-100; full evaluation accuracies are in Figure 19 (Appendix E). Comparing to Figure 6a and Figure 12 (Appendix E), we see that, relative to training against only $L _ { 2 }$ , joint training against $( L _ { \\infty } , L _ { 2 } )$ slightly improves robustness against $L _ { 1 }$ without harming robustness against other attacks. In contrast, training against $( L _ { \\infty } , L _ { 1 } )$ is worse than either training against $L _ { 1 }$ or $L _ { \\infty }$ separately (except at small $\\varepsilon$ for $L _ { 1 }$ ). Training against $( L _ { \\infty }$ , Elastic) also performs poorly. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            820
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Joint training and overfitting. Jointly trained models achieve high training accuracy but poor validation accuracy (Figure 8) that fluctuates substantially for different random seeds (Table 4, Appendix E.2). Figure 8 shows the overfitting behavior for $L _ { \\infty }$ , Elastic): $L _ { \\infty }$ validation accuracy decreases significantly during training while training accuracy increases. This contrasts with standard adversarial training (Figure 8), where validation accuracy levels off as training accuracy increases. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            900
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/58b2deb77fae4ade71fabd80f52f452df16aecef04abe171002af23557964b2e.jpg",
+        "image_caption": [
+            "Figure 8: Left: train and validation curves for joint training against $L _ { \\infty }$ , $\\varepsilon = 8$ and Elastic, $\\varepsilon = 4$ , Right: train and val curves for standard adversarial training for $L _ { \\infty }$ , $\\varepsilon = 8$ . The joint validation accuracy of $L _ { \\infty }$ decreases as training progresses, indicating overfitting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            102,
+            753,
+            213
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overfitting primarily occurs when training against large distortions. We successfully trained against the $( L _ { \\infty } , L _ { 1 } )$ and $( L _ { \\infty }$ , Elastic) pairs for small distortion sizes with accuracies comparable to but slightly lower than observed in Figure 11 for training against each attack individually (Figure 18, Appendix E). This agrees with behavior reported by Tramer & Boneh (2019) on CIFAR-10. Our \\` intuition is that harder training tasks (more diverse distortion types, larger $\\varepsilon$ ) make overfitting more likely. We briefly investigate the relation between overfitting and model capacity in Appendix E.3; validation accuracy appears slightly increased for ResNet-101, but overfitting remains. ",
+        "bbox": [
+            174,
+            282,
+            825,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            412,
+            488,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have seen that robustness to one attack provides limited information about robustness to other attacks, and moreover that adversarial training provides limited robustness to unforeseen attacks. These results suggest a need to modify or move beyond adversarial training. While joint adversarial training is one possible alternative, our results show it often leads to overfitting. Even ignoring this, it is not clear that joint training would confer robustness to attacks outside of those trained against. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluating robustness has proven difficult, necessitating detailed study of best practices even for a single fixed attack (Papernot et al., 2017; Athalye et al., 2018). We build on these best practices by showing how to choose and calibrate a diverse set of unforeseen attacks. Our work is a supplement to existing practices, not a replacement–we strongly recommend following the guidelines in Papernot et al. (2017) and Athalye et al. (2018) in addition to our recommendations. ",
+        "bbox": [
+            174,
+            526,
+            823,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Some caution is necessary when interpreting specific numeric results in our paper. Many previous implementations of adversarial training fell prone to gradient masking (Papernot et al., 2017; Engstrom et al., 2018), with apparently successful training occurring only recently (Madry et al., 2017; Xie et al., 2018). While evaluating with moderately many PGD steps (200) helps guard against this, (Qian & Wegman, 2019) shows that an $L _ { \\infty }$ -trained model that appeared robust against $L _ { 2 }$ actually had substantially less robustness when evaluating with $1 0 ^ { 6 }$ PGD steps. If this effect is pervasive, then there may be even less transfer between attacks than our current results suggest. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            702
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For evaluating against a fixed attack, DeepFool Moosavi-Dezfooli et al. (2015) and CLEVER Weng et al. (2018) can be seen as existing alternatives to UAR. They work by estimating “empirical robustness”, which is the expected minimum $\\varepsilon$ needed to successfully attack an image. However, these apply only to attacks which optimize over an $L _ { p }$ -ball of radius $\\varepsilon$ , and CLEVER can be susceptible to gradient masking Goodfellow (2018). In addition, empirical robustness is equivalent to linearly averaging accuracy over $\\varepsilon$ , which has smaller dynamic range than the geometric average in UAR. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our results add to a growing line of evidence that evaluating against a single known attack type provides a misleading picture of the robustness of a model (Sharma & Chen, 2017; Engstrom et al., 2017; Jordan et al., 2019; Tramer & Boneh, 2019; Jacobsen et al., 2019). Going one step further, \\` we believe that robustness itself provides only a narrow window into model behavior; in addition to robustness, we should seek to build a diverse toolbox for understanding machine learning models, including visualization (Olah et al., 2018; Zhang & Zhu, 2019), disentanglement of relevant features (Geirhos et al., 2018), and measurement of extrapolation to different datasets (Torralba & Efros, 2011) or the long tail of natural but unusual inputs (Hendrycks et al., 2019). Together, these windows into model behavior can give us a clearer picture of how to make models reliable in the real world. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Logan Engstrom, Andrew Ilyas, and Kevin Kwok. Synthesizing robust adversarial examples. CoRR, abs/1707.07397, 2017. URL http://arxiv.org/abs/1707.07397. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018. ",
+        "bbox": [
+            174,
+            164,
+            823,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tom B. Brown, Dandelion Mane, Aurko Roy, Mart ´ ´ın Abadi, and Justin Gilmer. Adversarial patch. CoRR, abs/1712.09665, 2017. URL http://arxiv.org/abs/1712.09665. ",
+        "bbox": [
+            171,
+            215,
+            823,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            171,
+            253,
+            825,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian J. Goodfellow, Aleksander Madry, and Alexey Kurakin. On evaluating adversarial robustness. CoRR, abs/1902.06705, 2019. URL http://arxiv.org/abs/1902.06705. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            334
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen, Yash Sharma, Huan Zhang, Jinfeng Yi, and Cho-Jui Hsieh. EAD: Elastic-net attacks to deep neural networks via adversarial examples. In Thirty-second AAAI conference on artificial intelligence, 2018. ",
+        "bbox": [
+            171,
+            342,
+            825,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kenneth T. Co, Luis Munoz-Gonz ˜ alez, and Emil C. Lupu. Sensitivity of deep convolutional net- ´ works to Gabor noise. CoRR, abs/1906.03455, 2019. URL http://arxiv.org/abs/ 1906.03455. ",
+        "bbox": [
+            171,
+            393,
+            823,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Francesco Croce and Matthias Hein. Provable robustness against all adversarial $l _ { p }$ -perturbations for $p \\geq 1$ . CoRR, abs/1905.11213, 2019. URL http://arxiv.org/abs/1905.11213. ",
+        "bbox": [
+            171,
+            445,
+            823,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            173,
+            484,
+            823,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling CNNs with simple transformations. arXiv preprint arXiv:1712.02779, 2017. ",
+        "bbox": [
+            171,
+            536,
+            823,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Andrew Ilyas, and Anish Athalye. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint arXiv:1807.10272, 2018. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nic Ford, Justin Gilmer, Nicolas Carlini, and Dogus Cubuk. Adversarial examples are a natural consequence of test error in noise. arXiv preprint arXiv:1901.10513, 2019. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marguerite Frank and Philip Wolfe. An algorithm for quadratic programming. Naval research logistics quarterly, 3(1-2):95–110, 1956. ",
+        "bbox": [
+            169,
+            664,
+            825,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and Wieland Brendel. ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. CoRR, abs/1811.12231, 2018. URL http://arxiv.org/ abs/1811.12231. ",
+        "bbox": [
+            173,
+            702,
+            825,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow. Gradient masking causes CLEVER to overestimate adversarial perturbation size. arXiv preprint arXiv:1804.07870, 2018. ",
+        "bbox": [
+            169,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            169,
+            805,
+            823,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An- ´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            174,
+            843,
+            821,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pp. 630–645. Springer, 2016. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Kevin Zhao, Steven Basart, Jacob Steinhardt, and Dawn Song. Natural adversarial examples. arXiv preprint arXiv:1907.07174, 2019. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jrn-Henrik Jacobsen, Jens Behrmannn, Nicholas Carlini, Florian Tramr, and Nicolas Papernot. Exploiting excessive invariance caused by norm-bounded adversarial robustness, 2019. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matt Jordan, Naren Manoj, Surbhi Goel, and Alexandros G. Dimakis. Quantifying perceptual distortion of adversarial examples. arXiv e-prints, art. arXiv:1902.08265, Feb 2019. ",
+        "bbox": [
+            171,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ares Lagae, Sylvain Lefebvre, George Drettakis, and Philip Dutre. Procedural noise using sparse ´ Gabor convolution. ACM Trans. Graph., 28(3):54:1–54:10, July 2009. ISSN 0730-0301. doi: 10. 1145/1531326.1531360. URL http://doi.acm.org/10.1145/1531326.1531360. ",
+        "bbox": [
+            178,
+            255,
+            823,
+            297
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. DeepFool: a simple and accurate method to fool deep neural networks. arXiv preprint arXiv:1511.04599, 2015. ",
+        "bbox": [
+            173,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arkadi Nemirovski and D Yudin. On Cezari’s convergence of the steepest descent method for approximating saddle point of convex-concave functions. In Soviet Math. Dokl, volume 19, pp. 258–269, 1978. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arkadi Nemirovski and D Yudin. Problem Complexity and Method Efficiency in Optimization. Intersci. Ser. Discrete Math. Wiley, New York, 1983. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris Olah, Arvind Satyanarayan, Ian Johnson, Shan Carter, Ludwig Schubert, Katherine Ye, and Alexander Mordvintsev. The building blocks of interpretability. Distill, 2018. doi: 10.23915/ distill.00010. https://distill.pub/2018/building-blocks. ",
+        "bbox": [
+            174,
+            484,
+            826,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia conference on computer and communications security, pp. 506–519. ACM, 2017. ",
+        "bbox": [
+            173,
+            536,
+            826,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haifeng Qian and Mark N. Wegman. $L _ { 2 }$ -nonexpansive neural networks. In International Conference on Learning Representations (ICLR), 2019. URL https://openreview.net/forum? id $=$ ByxGSsR9FQ. ",
+        "bbox": [
+            173,
+            588,
+            823,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yash Sharma and Pin-Yu Chen. Attacking the Madry defense model with $L _ { 1 }$ -based adversarial examples. arXiv e-prints, art. arXiv:1710.10733, Oct 2017. ",
+        "bbox": [
+            171,
+            640,
+            823,
+            670
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard Shin and Dawn Song. JPEG-resistant adversarial images. In NIPS 2017 Workshop on Machine Learning and Computer Security, 2017. ",
+        "bbox": [
+            169,
+            678,
+            825,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            171,
+            715,
+            823,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antonio Torralba and Alexei A. Efros. Unbiased look at dataset bias. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2011. ",
+        "bbox": [
+            169,
+            753,
+            823,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer and Dan Boneh. Adversarial training and robustness for multiple perturbations. \\` arXiv e-prints, art. arXiv:1904.13000, Apr 2019. ",
+        "bbox": [
+            168,
+            791,
+            823,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Igor Vasiljevic, Ayan Chakrabarti, and Gregory Shakhnarovich. Examining the impact of blur on recognition by convolutional networks. CoRR, abs/1611.05760, 2016. URL http://arxiv. org/abs/1611.05760. ",
+        "bbox": [
+            173,
+            829,
+            821,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsui-Wei Weng, Huan Zhang, Pin-Yu Chen, Jinfeng Yi, Dong Su, Yupeng Gao, Cho-Jui Hsieh, and Luca Daniel. Evaluating the robustness of neural networks: An extreme value theory approach. arXiv preprint arXiv:1801.10578, 2018. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chaowei Xiao, Jun-Yan Zhu, Bo Li, Warren He, Mingyan Liu, and Dawn Song. Spatially transformed adversarial examples. arXiv preprint arXiv:1801.02612, 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. arXiv preprint arXiv:1812.03411, 2018. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianyuan Zhang and Zhanxing Zhu. Interpreting adversarially trained convolutional neural networks. In International Conference on Machine Learning (ICML), 2019. ",
+        "bbox": [
+            173,
+            179,
+            821,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A TRAINING HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            467,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For ImageNet-100, we trained on machines with 8 NVIDIA V100 GPUs using standard data augmentation He et al. (2016). Following best practices for multi-GPU training Goyal et al. (2017), we ran synchronized SGD for 90 epochs with batch size $3 2 \\times 8$ and a learning rate schedule with 5 “warm-up” epochs and a decay at epochs 30, 60, and 80 by a factor of 10. Initial learning rate after warm-up was 0.1, momentum was 0.9, and weight decay was $1 0 ^ { - 4 }$ . For CIFAR-10, we trained on a single NVIDIA V100 GPU for 200 epochs with batch size 32, initial learning rate 0.1, momentum 0.9, and weight decay $1 0 ^ { - 4 }$ . We decayed the learning rate at epochs 100 and 150. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B FURTHER ATTACK DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            251,
+            439,
+            267
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 FURTHER EXAMPLES OF ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            282,
+            450,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We show the images corresponding to the ones in Figure 2, with the exception that they are not scaled. The non-scaled images are shown in Figure 9. ",
+        "bbox": [
+            174,
+            308,
+            823,
+            337
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 $L _ { 1 }$ ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            353,
+            297,
+            368
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We chose to use the Frank-Wolfe algorithm for optimizing the $L _ { 1 }$ attack, as Projected Gradient Descent would require projecting onto a truncated $L _ { 1 }$ ball, which is a complicated operation. In contrast, Frank-Wolfe only requires optimizing linear functions $g ^ { \\top } x$ over a truncated $L _ { 1 }$ ball; this can be done by sorting coordinates by the magnitude of $g$ and moving the top $k$ coordinates to the boundary of their range (with $k$ chosen by binary search). This is detailed in Algorithm 1. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C FULL EVALUATION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            444,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C.1 $L _ { 1 }$ -JPEG AND $L _ { 2 }$ -JPEG ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            452,
+            516
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We will present results with two additional versions of the JPEG attack which impose $L _ { 1 }$ or $L _ { 2 }$ constraints on the attack in JPEG-space instead of the $L _ { \\infty }$ constraint discussed in Section 2. To avoid confusion, in this appendix, we denote the original JPEG attack by $L _ { \\infty }$ -JPEG and these variants by $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG, respectively. Comparing the $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG attacks in Figure 10, ",
+        "bbox": [
+            174,
+            527,
+            825,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ac5967c0d22dc79a6ede0c106dbea07c0ee35bc92400d42a1b2854bac17752a.jpg",
+        "image_caption": [
+            "Figure 9: Differences of the attacked images and original image for different attacks (label “espresso maker”). The $L _ { 1 }$ , $L _ { 2 }$ , and $L _ { \\infty }$ norms of the difference are shown in parentheses. As shown, our novel attacks display qualitatively different behavior and do not fall under the $L _ { p }$ threat model. These differences are not scaled and are normalized so that no difference corresponds to white. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            609,
+            816,
+            864
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1: Input: function $f$ , initial input $x \\in [ 0 , 1 ] ^ { d }$ , $L _ { 1 }$ radius $\\rho$ , number of steps $T$ .   \n2: Output: approximate maximizer $\\bar { x }$ of $f$ over the truncated $L _ { 1 }$ ball $\\mathring { B _ { 1 } } ( \\rho ; x ) \\cap [ 0 , 1 ] ^ { d }$ centered   \nat $x$ .   \n3:   \n4: $x ^ { ( 0 ) } \\gets \\mathrm { R a n d o m I n i t } ( x )$ . Random initialization   \n5: for $t = 1 , \\dots , T$ do   \n6: g f (x(t−1)) . Obtain gradient   \n7: for $k = 1 , \\ldots , d { \\mathrm { } } $ do   \n8: $s _ { k } \\gets$ index of the coordinate of $g$ by with $k ^ { \\mathrm { { t h } } }$ largest norm   \n9: end for   \n10: $S _ { k } \\gets \\{ s _ { 1 } , \\ldots , s _ { k } \\} .$   \n11:   \n12: for $i = 1 , \\ldots , d$ do . Compute move to boundary of $[ 0 , 1 ]$ for each coordinate.   \n13: if $g _ { i } > 0$ then   \n14: $b _ { i } \\gets 1 - x _ { i }$   \n15: else   \n16: $b _ { i } \\gets - x _ { i }$   \n17: end if   \n18: end for   \n19: $\\begin{array} { r l } & { M _ { k } \\gets \\sum _ { i \\in S _ { k } } | b _ { i } | } \\\\ & { k ^ { * } \\gets \\operatorname* { m a x } \\{ k \\mid M _ { k } \\leq \\rho \\} } \\end{array}$ . Compute $L _ { 1 }$ -perturbation of moving $k$ largest coordinates.   \n20: $\\triangleright$ Choose largest $k$ satisfying $L _ { 1 }$ constraint.   \n21: for i = 1, . . . , d do $\\triangleright$ Compute $\\hat { x }$ maximizing $g ^ { \\top } x$ over the $L _ { 1 }$ ball.   \n22: if $i \\in S _ { k ^ { * } }$ then   \n23: xˆi ← xi + bi   \n24: else if $i = s _ { k ^ { * } + 1 }$ then   \n25: $\\hat { x } _ { i } \\gets x _ { i } + ( \\rho - M _ { k ^ { * } } ) \\operatorname { s i g n } ( g _ { i } )$   \n26: else   \n27: $\\hat { x } _ { i } \\gets x _ { i }$   \n28: end if   \n29: end for   \n30: $\\begin{array} { r } { x ^ { ( t ) }  ( 1 - \\frac { 1 } { t } ) x ^ { ( t - 1 ) } + \\frac { 1 } { t } \\hat { x } } \\end{array}$ . Average $\\hat { x }$ with previous iterates   \n31: end for   \n32: x¯ x(T) ",
+        "bbox": [
+            173,
+            121,
+            826,
+            588
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/ef5b12eaa3c30631bf8091efd9c431d7be2695ab234054c12b139eb9cc51c641.jpg",
+        "table_caption": [
+            "Algorithm 1 Pseudocode for the Frank-Wolfe algorithm for the $L _ { 1 }$ attack. ",
+            "Table 2: ATA values for $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG on ImageNet-100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>E1</td><td>E2</td><td>3</td><td>E4</td><td>5</td><td>6</td><td>ATA1</td><td>ATA2</td><td>ATA3</td><td>ATA4</td><td>ATA5</td><td>ATA6</td></tr><tr><td>L2-JPEG</td><td>8</td><td>16</td><td>32</td><td>64</td><td>128</td><td>256</td><td>84.8</td><td>82.5</td><td>78.9</td><td>72.3</td><td>47.5</td><td>3.4</td></tr><tr><td>L1-JPEG</td><td>256</td><td></td><td>10244096</td><td>16384</td><td>65536</td><td>131072</td><td>84.8</td><td>81.8</td><td>76.2</td><td>67.1</td><td>46.4</td><td>41.8</td></tr></table>",
+        "bbox": [
+            223,
+            643,
+            771,
+            685
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "we find that they have extremely similar results, so we omit $L _ { 1 }$ -JPEG in the full analysis for brevity and visibility. Calibration values for these attacks are shown in Table 2. ",
+        "bbox": [
+            174,
+            733,
+            823,
+            762
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.2 FULL EVALUATION RESULTS AND ANALYSIS FOR IMAGENET-100 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            666,
+            814
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We show the full results of all adversarial attacks against all adversarial defenses for ImageNet-100 in Figure 11. As described, the $L _ { p }$ attacks and defenses give highly correlated information on heldout defenses and attacks respectively. Thus, we recommend evaluating on a wide range of distortion types. Full UAR scores are also provided for ImageNet-100 in Figure 12. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We further show selected results in Figure 13. As shown, a wide range of $\\varepsilon$ is required to see the full behavior. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/866c62ff7619934861f9400f7e14b3b781a41eb94b70cee2d5971c263865942b.jpg",
+        "image_caption": [
+            "Figure 10: A comparison of $L _ { 1 }$ -JPEG and $L _ { 2 }$ -JPEG attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            534,
+            838
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/15ed640f6afd9cfaf42a569f89e9649ba332000d32eca1facb3c4af57d24a7cf.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            19,
+            190,
+            897,
+            916
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/f208902da7d75877a22d62981b6b41193b92a5ec6dc3950879f712a5112d524c.jpg",
+        "image_caption": [
+            "Figure 12: UAR scores (multiplied by 100) for adv. trained defenses (rows) against distortion types (columns) for ImageNet-100. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            818,
+            401
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/8521503b091168c4a6dbf8cb92a07c7ed673d88fd7aacaa4ce1797d67781bbff.jpg",
+        "image_caption": [
+            "Figure 13: Adversarial accuracies of attacks on adversarially trained models for different distortion sizes on ImageNet-100. For a given attack $\\varepsilon$ , the best $\\varepsilon ^ { \\prime }$ to train against satisfies $\\varepsilon ^ { \\prime } > \\varepsilon$ because the random scaling of $\\varepsilon ^ { \\prime }$ during adversarial training ensures that a typical distortion during adversarial training has size smaller than $\\varepsilon ^ { \\prime }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            457,
+            813,
+            648
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C.3 FULL EVALUATION RESULTS AND ANALYSIS FOR CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            632,
+            758
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C.3.1 FULL RESULTS FOR CIFAR10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            771,
+            439,
+            785
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We show the results of adversarial attacks and defenses for CIFAR-10 in Figure 14. We experienced difficulty training the $L _ { 2 }$ and $L _ { 1 }$ attacks at distortion sizes greater than those shown and have omitted those runs, which we believe may be related to the small size of CIFAR-10 images. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            838
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C.3.2 ATA AND UAR FOR CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            444,
+            871
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The $\\varepsilon$ calibration procedure for CIFAR-10 was similar to that used for ImageNet-100. We started with the perceptually small $\\varepsilon _ { \\mathrm { { m i n } } }$ values in Table 3 and increased $\\varepsilon$ geometrically with ratio 2 until adversarial accuracy of an adversarially trained model dropped below 40. Note that this threshold is higher for CIFAR-10 because there are fewer classes. The resulting ATA and UAR values for CIFAR10 are shown in Table 3 and Figure 15. We omitted calibration for the $L _ { 2 }$ -JPEG attack because we chose too small a range of $\\varepsilon$ for our initial training experiments, and we plan to address this issue in the future. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/a6b3e5c2d24edc588dc92be0a002bf365b134e50464a7db9479260fe81bc91ec.jpg",
+        "table_caption": [
+            "Table 3: Calibrated distortion sizes and ATA values for ResNet-56 on CIFAR-10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>1</td><td>£2</td><td>3</td><td>E4</td><td>ε5</td><td>6</td><td>ATA1</td><td>ATA2</td><td>ATA3</td><td>ATA4</td><td>ATA5</td><td>ATA6</td></tr><tr><td>L8</td><td>1</td><td>2</td><td>4</td><td>8</td><td>16</td><td>32</td><td>91.0</td><td>87.8</td><td>81.6</td><td>71.3</td><td>46.5</td><td>23.1</td></tr><tr><td>L2</td><td>40</td><td>80</td><td>160</td><td>320</td><td>640</td><td>2560</td><td>90.1</td><td>86.4</td><td>79.6</td><td>67.3</td><td>49.9</td><td>17.3</td></tr><tr><td>L1</td><td>195</td><td>390</td><td>780</td><td>1560</td><td></td><td>6240 24960</td><td>92.2</td><td>90.0</td><td>83.2</td><td>73.8</td><td>47.4</td><td>35.3</td></tr><tr><td>L-JPEG 0.03125 0.0625 0.125 0.25</td><td></td><td></td><td></td><td></td><td>0.5</td><td>1</td><td>89.7</td><td>87.0</td><td>83.1</td><td>78.6</td><td>69.7</td><td>35.4</td></tr><tr><td>L1-JPEG</td><td>2</td><td>8</td><td>64</td><td>256</td><td>512</td><td>1024</td><td>91.4</td><td>88.1</td><td>80.2</td><td>68.9</td><td>56.3</td><td>37.7</td></tr><tr><td>Elastic</td><td>0.125</td><td>0.25</td><td>0.5</td><td>1</td><td>2</td><td>8</td><td>87.4</td><td>81.3</td><td>72.1</td><td>58.2</td><td>45.4</td><td>27.8</td></tr></table>",
+        "bbox": [
+            189,
+            132,
+            808,
+            233
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            257,
+            825,
+            314
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D ROBUSTNESS OF OUR RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            338,
+            465,
+            354
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D.1 REPLICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            372,
+            313,
+            387
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We replicated our results for the first three rows of Figure 11 with different random seeds to see the variation in our results. As shown in Figure 16, deviations in results are minor. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            429
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D.2 CONVERGENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            449,
+            326,
+            464
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We replicated the results in Figure 11 with 50 instead of 200 steps to see how the results changed based on the number of steps in the attack. As shown in Figure 17, the deviations are minor. ",
+        "bbox": [
+            174,
+            477,
+            823,
+            507
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "E FURTHER RESULTS FOR JOINT TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            552,
+            547
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "E.1 FULL EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            431,
+            579
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We show the evaluation accuracies of jointly trained models in Figure 18. ",
+        "bbox": [
+            173,
+            592,
+            663,
+            608
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We show all the attacks against the jointly adversarially trained defenses in Figure 19. ",
+        "bbox": [
+            176,
+            613,
+            735,
+            628
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "E.2 DEPENDENCE ON RANDOM SEED ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            442,
+            665
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Table 4, we study the dependence of joint adversarial training to random seed. We find that at large distortion sizes, joint training for certain pairs of distortions does not produce consistent results over different random initializations. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            719
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/2b8c0a56d91cb20cb8467da9b573abfc820910c9a1a5b527f39a5a3692900e60.jpg",
+        "table_caption": [
+            "Table 4: Train and val accuracies for joint adversarial training at large distortion are dependent on seed. For train and val, $\\varepsilon ^ { \\prime }$ is chosen uniformly at random between 0 and $\\varepsilon$ , and we used 10 steps for $L _ { \\infty }$ and $L _ { 1 }$ and 30 steps for elastic. Single adversarial training baselines are also shown. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training parameters (ResNet-50)</td><td>Loo train</td><td>other train</td><td>Loval</td><td>other val</td></tr><tr><td>Lε=8,Elasticε=4,Seed1</td><td>90</td><td>89</td><td>35</td><td>74</td></tr><tr><td>Lε=8,Elastic ε=4,Seed 2</td><td>89</td><td>90</td><td>47</td><td>44</td></tr><tr><td>Lε=8,Elastic ε=4,Seed 3</td><td>90</td><td>89</td><td>29</td><td>63</td></tr><tr><td>Loε=16,L1ε=612000,Seed1</td><td>86</td><td>87</td><td>22</td><td>16</td></tr><tr><td>Loε=16,L1ε=612000,Seed 2</td><td>88</td><td>87</td><td>16</td><td>24</td></tr><tr><td>Lε=8</td><td>81</td><td>1</td><td>74</td><td>1</td></tr><tr><td>L∞ε=16</td><td>68</td><td>1</td><td>63</td><td>1</td></tr><tr><td>Elastic ε=4</td><td>1</td><td>88</td><td>1</td><td>76</td></tr><tr><td>L1ε= 612000</td><td>1</td><td>75</td><td>1</td><td>59</td></tr></table>",
+        "bbox": [
+            235,
+            785,
+            761,
+            916
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/6eb25600f7c7e6f32d9f52e2df8fd6d51c5950bf5387e2d1e6f122778652dd53.jpg",
+        "table_caption": [
+            "Table 5: Training and validation numbers for ResNet-101 and ResNet-50 for joint training against $L _ { \\infty }$ , $\\varepsilon = 8$ and elastic, $\\varepsilon = 4$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Trainingparameters</td><td>L train</td><td>other train</td><td>Looval</td><td>other val</td></tr><tr><td>Lε= 8,Elastic ε = 4,ResNet-50 Seed 1</td><td>90</td><td>89</td><td>35</td><td>74</td></tr><tr><td>Lε= 8,Elastic ε = 4,ResNet-50 Seed 2</td><td>89</td><td>90</td><td>47</td><td>44</td></tr><tr><td>Lε= 8,Elastic ε= 4 ResNet-101</td><td>90</td><td>91</td><td>49</td><td>46</td></tr></table>",
+        "bbox": [
+            189,
+            147,
+            808,
+            207
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "E.3 OVERFITTING AND MODEL CAPACITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            229,
+            473,
+            244
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "As a first test to understand the relationship between model capacity and overfitting, we trained ResNet-101 models using the same procedure as in Section 5. Briefly, overfitting still occurs, but ResNet-101 achieves a few percentage points higher than ResNet-50. ",
+        "bbox": [
+            176,
+            256,
+            825,
+            297
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "We show the training curves in Figure 20 and the training and validation numbers in Table 5. ",
+        "bbox": [
+            174,
+            304,
+            779,
+            319
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "F COMPARING ADVERSARIAL DISTORTIONS AND COMMON CORRUPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            340,
+            799,
+            356
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "“Common” visual corruptions such as (non-adversarial) fog, blur, or pixelation have emerged as another avenue for measuring the robustness of computer vision models (Vasiljevic et al., 2016; Hendrycks & Dietterich, 2019; Geirhos et al., 2018). Recent work suggests that robustness to such common corruptions is linked to adversarial robustness and proposes corruption robustness as an easily computed indicator of adversarial robustness (Ford et al., 2019). We consider this alternative to our methodology by testing corruption robustness of our models on the ImageNet-C benchmark. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            454
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup. We evaluate on the 100-class subset of the corruption robustness benchmark ImageNet-C introduced in (Hendrycks & Dietterich, 2019) with the same classes as ImageNet-100, which we call ImageNet-C-100. It is the ImageNet-100 validation set with 19 common corruptions at 5 severities. We use the JPEG files available at https://github.com/hendrycks/ robustness. We show average accuracies by distortion type in Figure 21. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            535
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training against small distortions increases corruption robustness. The first column of each block in Figure 21 shows that training against small adversarial distortions generally increases average accuracy compared to an undefended model. However, training against larger distortions often decreases average accuracy, largely due to the resulting decrease in clean accuracy. ",
+        "bbox": [
+            174,
+            545,
+            823,
+            601
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Adversarial distortions and common corruptions can affect defenses differently. Our $L _ { p }$ -JPEG and elastic attacks are adversarial versions of the corresponding common corruptions. While training against adversarial JPEG at larger $\\varepsilon$ improves robustness against adversarial JPEG attacks (Figure 12 in Appendix C.2), Figure 21 shows that robustness against common JPEG corruptions decreases as we adversarially train against JPEG at larger $\\varepsilon$ , though it remains better than for normally trained models. Similarly, adversarial Elastic training at large $\\varepsilon$ begins to hurt robustness to its common counterpart. This is likely because common corruptions are easier than adversarial distortions, hence the increased robustness does not make up for the decreased clean accuracy. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            722
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "G ATTACKS AGAINST UNDEFENDED MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            743,
+            562,
+            758
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "We show sample images of our attacks against undefended models trained in the normal way in Figure 22. ",
+        "bbox": [
+            176,
+            773,
+            825,
+            803
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5b8f6b51871c6a0f11fb44cfefdc1dea2a5dd2db4a4d0c28fe23116677a6a26.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            26,
+            195,
+            867,
+            924
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c4e73dc2723aa7c3ff293a9a09c0b880a5c6c3f7550840ab4050ca4c424aaac.jpg",
+        "image_caption": [
+            "Figure 15: UAR scores on CIFAR-10. Displayed UAR scores are multiplied by 100 for clarity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            143,
+            813,
+            375
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/65f7ff576df4174255ea289276b086b77df68cad821a354c04d96e086f25d260.jpg",
+        "image_caption": [
+            "Figure 16: Replica of the first three block rows of Figure 11 with different random seeds. Deviations in results are minor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            574,
+            787,
+            840
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/6d1496d4291d97b42becddbf4d3547aa618349688b1e535c348aeaebda6c32e3.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            19,
+            190,
+            906,
+            917
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/ded149cae3872a9d542dd33f0b1c5c0b791035dd74d30e540c63c3cea29598ee.jpg",
+        "image_caption": [
+            "Figure 18: Evaluation accuracies of jointly trained models. Attack and training $\\varepsilon$ values are equal. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            130,
+            812,
+            382
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/40e99c031d044efe49fd15d28bbe5c484490bfc2d61019c7bed9bf530aa7f0cc.jpg",
+        "image_caption": [
+            "Figure 19: All attacks (columns) vs. jointly adversarially trained defense (rows). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            477,
+            815,
+            643
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7e7161e19fc6c98cc3b875c7e4cf96613fdeb7b1a7e9ce0a6a179944c8a7ed9.jpg",
+        "image_caption": [
+            "Figure 20: Train and validation curves for joint training against $L _ { \\infty }$ , $\\varepsilon = 4$ and elastic, $\\varepsilon = 8$ using ResNet-101. As shown, the validation accuracies decrease as training progresses, indicating overfitting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            739,
+            728,
+            838
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/aed8ae41d6c19ccf263818714ff2666fa1ad3c9fff93218a083dd2377626c5ac.jpg",
+        "image_caption": [
+            "Figure 21: Accuracies of defenses (rows) on ImageNet-C-100 corruptions (columns). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            162,
+            823,
+            401
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba71eedb6d42fa3e008d3220da4fc4756004f0e059682f5d6fef415a5e30e90e.jpg",
+        "image_caption": [
+            "Figure 22: Adversarial attacks at low distortion sizes $\\varepsilon$ against an undefended model. The pair of (ε, accuracy) is shown after the attack name. Visual differences between the original and attacked images are imperceptible for $L _ { \\infty }$ , $L _ { 2 }$ , and JPEG, minor for $L _ { 1 }$ , Elastic, and Gabor, and weatherrelated for Fog and Snow. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            574,
+            834,
+            799
+        ],
+        "page_idx": 22
+    }
+]

parse/train/S1g2V3Cct7/S1g2V3Cct7.md

@@ -0,0 +1,256 @@
+# EXPERIENCE REPLAY FOR CONTINUAL LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Continual learning is the problem of learning new tasks or knowledge while protecting old knowledge and ideally generalizing from old experience to learn new tasks faster. Neural networks trained by stochastic gradient descent often degrade on old tasks when trained successively on new tasks with different data distributions. This phenomenon, referred to as catastrophic forgetting, is considered a major hurdle to learning with non-stationary data or sequences of new tasks, and prevents networks from continually accumulating knowledge and skills. We examine this issue in the context of reinforcement learning, in a setting where an agent is exposed to tasks in a sequence. Unlike most other work, we do not provide an explicit indication to the model of task boundaries, which is the most general circumstance for a learning agent exposed to continuous experience. While various methods to counteract catastrophic forgetting have recently been proposed, we explore a straightforward, general, and seemingly overlooked solution – that of using experience replay buffers for all past events – with a mixture of on- and off-policy learning, leveraging behavioral cloning. We show that this strategy can still learn new tasks quickly yet can substantially reduce catastrophic forgetting in both Atari and DMLab domains, even matching the performance of methods that require task identities. When buffer storage is constrained, we confirm that a simple mechanism for randomly discarding data allows a limited size buffer to perform almost as well as an unbounded one.
+
+# 1 INTRODUCTION
+
+Modern day reinforcement learning (RL) has benefited substantially from a massive influx of computational resources. In some instances, the number of data points to feed into RL algorithms has kept in step with computational feasibility. For example, in simulation environments or in self-play RL, it is possible to generate fresh data on the fly. In such settings, the continual learning problem (Ring, 1997) is often ignored because new experiences can be collected on demand, and the start states of the simulation can be controlled. When training on multiple tasks, it is possible to train on all environments simultaneously within the same data batch.
+
+As RL is increasingly applied to problems in industry or other real-world settings, however, it is necessary to consider cases, such as robotics, where gathering new experience is expensive or difficult. In such examples, simultaneous training may be infeasible. Instead, an agent must be able to learn from only one task at a time. The time spent on different tasks and the sequence in which those tasks occur are not under the control of the agent. The boundaries between tasks, in fact, will often be unknown – or tasks will deform continuously and not have definite boundaries at all. Such a paradigm for training eliminates the possibility of simultaneously acting upon and learning from several tasks, and leads to the danger of catastrophic forgetting, wherein an agent forgets what it has learned previously when it encounters a new situation.
+
+Here, we consider the setting of reinforcement learning where compute and memory resources are large, but the environment is not stationary: this may arise because an RL agent is encountering a task curriculum or sequence of unrelated tasks, engaged in a budgeted physical interaction within a robot, or learning from unstructured interaction with humans. In this setting, the problem of continual learning rears its head: the distribution over experiences is not controlled to facilitate the agent’s maintenance of previously acquired ability.
+
+An ideal continual learning system should meet three requirements. First, it should retain previously learned capacities. When a previously encountered task or situation is encountered, performance should immediately be good – ideally as good as it was historically. Second, maintenance of old skills or knowledge should not inhibit further rapid acquisition of a new skill or knowledge. These two simultaneous constraints – maintaining the old while still adapting to the new – represent the challenge known as the stability-plasticity dilemma Grossberg (1982). Third, where possible, a continual learning system should learn new skills that are related to old ones faster than it would have de novo, a property known as constructive interference or positive transfer.
+
+![](images/2f2e8e397f02c2fb4e044236788ce53437ac3519732f819028385a81cf923fc9.jpg)  
+Figure 1: Separate, simultaneous, and sequential training: the $x$ -axis denotes environment steps summed across all tasks and the $y$ -axis episode score. In “Sequential”, thick line segments are used to denote the task currently being trained, while thin segments are plotted by evaluating performance without learning. In simultaneous training, performance on explore object locations small is higher than in separate training, an example of modest constructive interference. In sequential training, tasks that are not currently being learned exhibit very dramatic catastrophic forgetting. (See Appendix C for a different plot of these data.)
+
+We here demonstrate the surprising power of a simple approach: Continual Learning with Experience And Replay (CLEAR). We show that training a network on a mixture of novel experience on-policy and replay experience off-policy allows for both maintenance of performance on earlier tasks and fast adaptation to new tasks. A significant further boost in performance and reduction in catastrophic forgetting is obtained by enforcing behavioral cloning between the current policy and its past self. While memory is rarely severely limited in modern RL, we show that small replay buffers filled with uniform samples from past experiences can be almost as effective as buffers of unbounded size. When comparing CLEAR against state-of-the-art approaches for reducing catastrophic forgetting, we obtain better or comparable results, despite the relative simplicity of our approach; yet, crucially, CLEAR requires no information about the identity of tasks or boundaries between them.
+
+# 2 RELATED WORK
+
+The problem of catastrophic forgetting in neural networks has long been recognized (Grossberg, 1982), and it is known that rehearsing past data can be a satisfactory antidote for some purposes (McClelland, 1998; French, 1999). Consequently, in the supervised setting that is the most common paradigm in machine learning, catastrophic forgetting has been accorded less attention than in cognitive science or neuroscience, since a fixed dataset can be reordered and replayed as necessary to ensure high performance on all samples.
+
+In recent years, however, there has been renewed interest in overcoming catastrophic forgetting in RL contexts and in supervised learning from streaming data (Parisi et al., 2018). Current strategies for mitigating catastrophic forgetting have primarily focused on schemes for protecting the parameters inferred in one task while training on another. For example, in Elastic Weight Consolidation (EWC) (Kirkpatrick et al., 2017), weights important for past tasks are constrained to change more slowly while learning new tasks. The Progressive Networks approach (Rusu et al., 2016) freezes subnetworks trained on individual tasks, and Progress & Compress (Schwarz et al., 2018) uses EWC to consolidate the network after each task has been learned. Kaplanis et al. (2018) treat individual synaptic weights as dynamical systems with latent dimensions / states that protect information. Outside of RL, Zenke et al. (2017) develop a method similar to EWC that maintains estimates of the importance of weights for past tasks, Li & Hoiem (2017) leverage a mixture of task-specific and shared parameters, and Milan et al. (2016) develop a rigorous Bayesian approach for estimating unknown task boundaries. Notably all these methods assume that task identities or boundaries are known, with the exception of Milan et al. (2016), for which the approach is likely not scalable to highly complex tasks.
+
+![](images/cb086f3d51af01fdad811ec99b216226b67686d5eb249644ae8e52beb016326d.jpg)  
+Figure 2: Demonstration of CLEAR on three DMLab tasks, which are trained cyclically in sequence. CLEAR reduces catastrophic forgetting so significantly that sequential tasks train almost as well as simultaneous tasks (see Figure 1). When the behavioral cloning loss terms are ablated, there is still reduced forgetting from off-policy replay alone. As above, thicker line segments are used to denote the task that is currently being trained. (See Appendix C for a different plot of these data.)
+
+Rehearsing old data via experience replay buffers is a common technique in RL. However, their introduction has primarily been driven by the goal of data-efficient learning on single tasks (Lin, 1992; Mnih et al., 2015; Gu et al., 2017). Research in this vein has included prioritized replay for maximizing the impact of rare experiences (Schaul et al., 2016), learning from human demonstration data seeded into a buffer (Hester et al., 2017), and methods for approximating replay buffers with generative models (Shin et al., 2017). A noteworthy use of experience replay buffers to protect against catastrophic forgetting was demonstrated in Isele & Cosgun (2018) on toy tasks, with a focus on how buffers can be made smaller. Previous works (Gu et al., 2017; O’Donoghue et al., 2016; Wang et al., 2016) have explored mixing on- and off-policy updates in RL, though these were focused on speed and stability in individual tasks and did not examine continual learning. Here, in CLEAR, we demonstrate that a mixture of replay data and fresh experience protects against catastrophic forgetting while also permitting fast learning, and performs better than either pure onpolicy learning or pure off-policy learning from replay. We provide a thorough investigation and robust algorithm in CLEAR, conducting a wide variety of tests on both limited-size and unbounded buffers with complex RL tasks using state-of-the-art methods, and improve the stability of simple replay with the addition of behavioral cloning.
+
+# 3 THE CLEAR METHOD
+
+CLEAR uses actor-critic training on a mixture of new and replayed experiences. In the case of replay experiences, two additional loss terms are added to induce behavioral cloning between the network and its past self. The motivation for behavioral cloning is to prevent network output on replayed tasks from drifting while learning new tasks. We penalize (1) the KL divergence between the historical policy distribution and the present policy distribution, (2) the L2 norm of the difference between the historical and present value functions. Formally, this corresponds to adding the following loss functions, defined with respect to network parameters $\theta$ :
+
+$$
+L _ { \mathrm { p o l i c y - c l o n i n g } } : = \sum _ { a } \mu ( a | h _ { s } ) \log { \frac { \mu ( a | h _ { s } ) } { \pi _ { \theta } ( a | h _ { s } ) } } ,
+$$
+
+$$
+L _ { \mathrm { v a l u e - c l o n i n g } } : = | | V _ { \theta } ( h _ { s } ) - V _ { \mathrm { r e p l a y } } ( h _ { s } ) | | _ { 2 } ^ { 2 } ,
+$$
+
+where $\pi _ { \theta }$ denotes the (current) policy of the network over actions $a , \mu$ the policy generating the observed experience, and $h _ { s }$ the hidden state of the network at time $s$ . Note that computing $\bar { \mathrm { K L } } [ \mu | | \pi _ { \theta } ]$ instead of $\operatorname { K L } [ \pi _ { \boldsymbol { \theta } } | | \mu ]$ ensures that $\pi _ { \boldsymbol { \theta } } ( a | h _ { s } )$ is nonzero wherever the historical policy is as well.
+
+We apply CLEAR in a distributed training context based on the Importance Weighted Actor-Learner Architecture (Espeholt et al., 2018). A single learning network is fed experiences (both novel and
+
+![](images/2eafc7a1ca6c7c1be52871ecd3f8172b22ac53af14a7311a7911455d3b0ff395.jpg)  
+Figure 3: Comparison between different proportions of new and replay examples while cycling training among three tasks. We observe that with a 75-25 new-replay split, CLEAR eliminates most, but not all, catastrophic forgetting. At the opposite extreme, $100 \%$ replay prevents forgetting at the expense of reduced overall performance (with an especially noticeable reduction in early performance on the task rooms keys doors puzzle). A 50-50 split represents a good tradeoff between these extremes. (See Appendix C for a different plot of these data.)
+
+replay) by a number of acting networks, for which the weights are asynchronously updated to match those of the learner. The network architecture and hyperparameters are chosen as in Espeholt et al. (2018). Training proceeds according to V-Trace. Namely, define the V-Trace target $v _ { s }$ by:
+
+$$
+v _ { s } : = V ( h _ { s } ) + \sum _ { t = s } ^ { s + n - 1 } \gamma ^ { t - s } \left( \prod _ { i = s } ^ { t - 1 } c _ { i } \right) \delta _ { t } V ,
+$$
+
+where $\delta _ { t } V : = \rho _ { t } \left( r _ { t } + \gamma V ( h _ { t + 1 } ) - V ( h _ { t } ) \right)$ , $\begin{array} { r } { c _ { i } : = \operatorname* { m i n } ( \bar { c } , \frac { \pi _ { \theta } ( a _ { i } | h _ { i } ) } { \mu ( a _ { i } | h _ { i } ) } ) } \end{array}$ , and $\begin{array} { r } { \rho _ { t } = \operatorname* { m i n } ( \bar { \rho } , \frac { \pi _ { \theta } ( a _ { t } | h _ { t } ) } { \mu ( a _ { t } | h _ { t } ) } ) } \end{array}$ , for constants $\bar { c }$ and $\bar { \rho }$ .
+
+Then, the value function update is given by the L2 loss:
+
+$$
+L _ { \mathrm { v a l u e } } : = \left( V _ { \theta } ( h _ { s } ) - v _ { s } \right) ^ { 2 } .
+$$
+
+The policy gradient loss is:
+
+$$
+\begin{array} { r } { L _ { \mathrm { p o l i c y - g r a d i e n t } } : = - \rho _ { s } \log \pi _ { \theta } ( a _ { s } | h _ { s } ) \left( r _ { s } + \gamma v _ { s + 1 } - V _ { \theta } ( h _ { s } ) \right) . } \end{array}
+$$
+
+We also use an entropy loss:
+
+$$
+L _ { \mathrm { e n t r o p y } } : = \sum _ { a } \pi _ { \theta } ( a | h _ { s } ) \log \pi _ { \theta } ( a | h _ { s } ) .
+$$
+
+The loss functions $L _ { \mathrm { v a l u e } }$ , $L _ { \mathrm { p o l i c y - g r a d i e n t } }$ , and $L _ { \mathrm { e n t r o p y } }$ are applied both for new and replay experiences. In addition, we add $L _ { \mathrm { p o l i c y - c l o n i n g } }$ and $L _ { \mathrm { v a l u e - c l o n i n g } }$ for replay experiences only. In general, our experiments use a 50-50 mixture of novel and replay experiences, though performance does not appear to be very sensitive to this ratio. Further implementation details are given in Appendix A.
+
+# 4 RESULTS
+
+# 4.1 CATASTROPHIC FORGETTING VS. INTERFERENCE
+
+Our first experiment (Figure 1) was designed to distinguish between two distinct concepts that are sometimes conflated, interference and catastrophic forgetting, and to emphasize the outsized role of the latter as compared to the former. Interference occurs when two or more tasks are incompatible (destructive interference) or mutually helpful (constructive interference) within the same model. Catastrophic forgetting occurs when a task’s performance goes down not as a result of incompatibility with another task but as a result of the second task overwriting it within the model. As we aim to illustrate, the two are independent phenomena, and while interference may happen, forgetting is ubiquitous.
+
+We considered a set of three distinct tasks within the DMLab set of environments (Beattie et al., 2016), and compared three training paradigms on which a network may be trained to perform these three tasks: (1) Training networks on the individual tasks separately, (2) training a single network examples from all tasks simultaneously (which permits interference among tasks), and (3) training a single network sequentially on examples from one task, then the next task, and so on cyclically. Across all training protocols, the total amount of experience for each task was held constant. Thus, for separate networks training on separate tasks, the $x$ -axis in our plots shows the total number of environment frames summed across all tasks. For example, at three million frames, one million were on task 1, one million on task 2, and one million on task 3. This allows a direct comparison to simultaneous training, in which the same network was trained on all three tasks.
+
+![](images/47e101294e49148bab9ed0b66dd2d526575f7c469e3b5ebf880e5002a42edafe.jpg)  
+Figure 4: Comparison of the performance of training with different buffer sizes, using reservoir sampling to ensure that each buffer stores a uniform sample from all past experience. We observe only minimal difference in performance, with the smallest buffer (storing 1 in 200 experiences) demonstrating some catastrophic forgetting. (See Appendix C for a different plot of these data.)
+
+We observe that in DMLab, there is very little difference between separate and simultaneous training. This indicates minimal interference between tasks. If anything, there is a small amount of constructive interference, with simultaneous training performing slightly better than separate training. We assume this is a result of (i) commonalities in image processing required across different tasks, and (ii) certain basic exploratory behaviors, e.g., moving around, that are advantageous across tasks. (By contrast, destructive interference might result from incompatible behaviors or from insufficient model capacity.)
+
+By contrast, there is a large difference between either of the above modes of training and sequential training, where performance on a task decays immediately when training switches to another task – that is, catastrophic forgetting. Note that the performance of the sequential training appears at some points to be greater than that of separate training. This is purely because in sequential training, training proceeds exclusively on a single task, then exclusively on another task. For example, the first task quickly increases in performance since the network is effectively seeing three times as much data on that task as the networks training on separate or simultaneous tasks.
+
+# 4.2 CLEAR
+
+We here demonstrate the efficacy of CLEAR for diminishing catastrophic forgetting (Figure 2). We apply CLEAR to the cyclically repeating sequence of DMLab tasks used in the preceding experiment. Our method effectively eliminates forgetting on all three tasks, while preserving overall training performance (see “Sequential” training in Figure 1 for reference). When the task switches, there is little, if any, dropoff in performance when using CLEAR, and the network picks up immediately where it left off once a task returns later in training. Without behavioral cloning, the mixture of new experience and replay still reduces catastrophic forgetting, though the effect is reduced.
+
+# 4.3 BALANCE OF ON- AND OFF-POLICY LEARNING
+
+In this experiment (Figure 3), we consider the ratio of new examples to replay examples during training. Using $100 \%$ new examples is simply standard training, which as we have seen is subject to dramatic catastrophic forgetting. At 75-25 new-replay, there is already significant resistance to forgetting. At the opposite extreme, $100 \%$ replay examples is extremely resistant to catastrophic forgetting, but at the expense of a (slight) decrease in performance attained. We believe that 50- 50 new-replay represents a good tradeoff, combining significantly reduced catastrophic forgetting with no appreciable decrease in performance attained. Unless otherwise stated, our experiments on CLEAR will use a 50-50 split of new and replay data in training.
+
+![](images/6218075b072f0c8049d2f1132cb0160eb8889f9b62be607d20a1da603c7a9047.jpg)  
+Figure 5: The DMLab task natlab varying map randomize (brown line) is presented at different positions within a cyclically repeating sequence of three other DMLab tasks. We find that (1) performance on the probe task is independent of its position in the sequence, (2) the effectiveness of CLEAR does not degrade as more experiences and tasks are introduced into the buffer.
+
+It is notable that it is possible to train purely on replay examples, since the network has essentially no on-policy learning. In fact, the figure shows that with $100 \%$ replay, performance on each task increases throughout, even when on-policy learning is being applied to a different task. Just as Figure 2 shows the importance of behavioral cloning for maintaining past performance on a task, so this experiment shows that off-policy learning can actually increase performance from replay alone. Both ingredients are necessary for the success of CLEAR.
+
+# 4.4 LIMITED-SIZE BUFFERS
+
+In some cases, it may be impractical to store all past experiences in the replay buffer. We therefore test the efficacy of buffers that have capacity for only a relatively small number of experiences (Figure 4). Once the buffer is full, we use reservoir sampling to decide when to replace elements of the buffer with new experiences (Isele & Cosgun, 2018) (see details in Appendix A). Thus, at each point in time, the buffer contains a (fixed size) sample uniformly at random of all past experiences.
+
+We consider a sequence of tasks with 900 million environmental frames, comparing a large buffer of capacity 450 million to two small buffers of capacity 5 and 50 million. We find that all buffers perform well and conclude that it is possible to learn and reduce catastrophic forgetting even with a replay buffer that is significantly smaller than the total number of experiences. Decreasing the buffer size to 5 million results in a slight decrease in robustness to catastrophic forgetting. This may be due to over-fitting to the limited examples present in the buffer, on which the learner trains disproportionately often.
+
+# 4.5 LEARNING A NEW TASK QUICKLY
+
+It is a reasonable worry that relying on a replay buffer could cause new tasks to be learned more slowly as the new task data will make up a smaller and smaller portion of the replay buffer as the buffer gets larger. In this experiment (Figure 5), we find that this is not a problem for CLEAR, relying as it does on a mixture of off- and on-policy learning. Specifically, we find the performance attained on a task is largely independent of the amount of data stored in the buffer and on the identities of the preceding tasks. We consider a cyclically repeating sequence of three DMLab tasks. At different points in the sequence, we insert a fourth DMLab task as a “probe”. We find that the performance attained on the probe task is independent of the point at which it is introduced within the training sequence. This is true both for normal training and for CLEAR. Notably, CLEAR succeeds in greatly reducing catastrophic forgetting for all tasks, and the effect on the probe task does not diminish as the probe task is introduced later on in the training sequence. See also Appendix B for an experiment demonstrating that pure off-policy learning performs quite differently in this setting.
+
+# 4.6 COMPARISON TO P&C AND EWC
+
+Finally, we compare our method to Progress & Compress (P&C) (Schwarz et al., 2018) and Elastic Weight Consolidation (EWC) (Kirkpatrick et al., 2017), state-of-the-art methods for reducing catastrophic forgetting that, unlike replay, assume that the boundaries between different tasks are known (Figure 6). We use exactly the same sequence of Atari tasks as the authors of P&C (Schwarz et al., 2018), with the same time spent on each task. Likewise, the network and hyperparameters we use are designed to match exactly those used in Schwarz et al. (2018). This is simplified by the authors of P&C also using a training paradigm based on that in Espeholt et al. (2018). In this case, we use CLEAR with a 75-25 balance of new-replay experience.
+
+We find that we obtain comparable performance to P&C and better performance than EWC, despite CLEAR being significantly simpler and agnostic to the boundaries between tasks. On tasks krull, hero, and ms pacman, we obtain significantly higher performance than P&C (as well as EWC), while on beam rider and star gunner, P&C obtains higher performance. It is worth noting that though the on-policy model (baseline) experiences significant catastrophic forgetting, it also rapidly re-acquires its previous performance after re-exposure to the task; this allows baseline to be cumulatively better than EWC on some tasks (as is noted in the original paper Kirkpatrick et al. (2017)). An alternative plot of this experiment, showing cumulative performance on each task, is presented in Appendix C.
+
+# 5 DISCUSSION
+
+Some version of replay is believed to be present in biological brains. We do not believe that our implementation is reflective of neurobiology, though there are potential connections; hippocampal replay has been proposed as a systems-level mechanism to reduce catastrophic forgetting and improve generalization as in the theory of complementary learning systems (McClelland, 1998). This contrasts to some degree with synapse-level consolidation, which is also believed to be present in biology (Benna & Fusi, 2016), but is more like continual learning methods that protect parameters.
+
+Indeed, algorithms for continual learning may live on a Pareto frontier: different methods may have different regimes of applicability. In cases for which storing a large memory buffer is truly prohibitive, methods that protect inferred parameters, such as Progress & Compress, may be more suitable than replay methods. When task identities are available or boundaries between tasks are very clear, leveraging this information may reduce memory or computational demands or be useful to alert the agent to engage in rapid learning. Further, there exist training scenarios that are adversarial either to our method or to any method that prevents forgetting. For example, if the action space of a task were changed during training, fitting to the old policy’s action distribution, whether through behavioral cloning, off-policy learning, weight protection, or any of a number of other strategies for preventing catastrophic forgetting, could have a deleterious effect on future performance. For such cases, we may need to develop algorithms that selectively protect skills as well as forget them.
+
+![](images/5a16653237c5e89a85928694b32a4fd98d9904a59816efa45cd016632315b34c.jpg)  
+Figure 6: Comparison of CLEAR to Progress & Compress (P&C) and Elastic Weight Consolidation (EWC). We find that CLEAR demonstrates comparable or greater performance than these methods, despite being significantly simpler and not requiring any knowledge of boundaries between tasks. (See Appendix C for a different plot of these data.)
+
+We have explored CLEAR in a range of continual learning scenarios; we hope that some of the experimental protocols, such as probing with a novel task at varied positions in a training sequence, may inspire other research. Moving forward, we anticipate many algorithmic innovations that build on the ideas set forward here. For example, weight-consolidation techniques such as Progress & Compress are quite orthogonal to our approach and could be married with it for further performance gains. Moreover, while the V-Trace algorithm we use is effective at off-policy correction for small shifts between the present and past policy distributions, it is possible that off-policy approaches leveraging Q-functions, such as Retrace (Munos et al., 2016), may prove more powerful still.
+
+We have described a simple but powerful approach for preventing catastrophic forgetting in continual learning settings. CLEAR uses on-policy learning on fresh experiences to adapt rapidly to new tasks, while using off-policy learning with behavioral cloning on replay experience to maintain and modestly enhance performance on past tasks. Behavioral cloning on replay data further enhances the agent’s stability. Our method is simple, scalable, and practical; it takes advantage of the general abundance of memory and storage in modern computers and computing facilities. We believe that the broad applicability and simplicity of the approach make CLEAR a candidate “first line of defense” against catastrophic forgetting in many RL contexts.
+
+# REFERENCES
+
+Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler, ¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. DeepMind Lab. ´ Preprint arXiv:1612.03801, 2016.
+
+Marcus K Benna and Stefano Fusi. Computational principles of synaptic memory consolidation. Nature neuroscience, 19(12):1697, 2016.
+
+Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymir Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. IMPALA: Scalable distributed Deep-RL with importance weighted actor-learner architectures. In ICML, 2018.
+
+Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3(4):128–135, 1999.
+
+Stephen Grossberg. How does a brain build a cognitive code? In Studies of mind and brain, pp. 1–52. Springer, 1982.
+
+Shixiang Gu, Tim Lillicrap, Richard E Turner, Zoubin Ghahramani, Bernhard Scholkopf, and Sergey ¨ Levine. Interpolated policy gradient: Merging on-policy and off-policy gradient estimation for deep reinforcement learning. In NIPS, 2017.
+
+Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Gabriel Dulac-Arnold, et al. Deep Q-learning from demonstrations. Preprint arXiv:1704.03732, 2017.
+
+David Isele and Akansel Cosgun. Selective experience replay for lifelong learning. In AAAI, 2018.
+
+Christos Kaplanis, Murray Shanahan, and Claudia Clopath. Continual reinforcement learning with complex synapses. Preprint arXiv:1802.07239, 2018.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. In Proceedings of the National Academy of Sciences, 2017.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2017.
+
+Long-Ji Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine learning, 8(3-4):293–321, 1992.
+
+James L McClelland. Complementary learning systems in the brain: A connectionist approach to explicit and implicit cognition and memory. Annals of the New York Academy of Sciences, 843 (1):153–169, 1998.
+
+Kieran Milan, Joel Veness, James Kirkpatrick, Michael Bowling, Anna Koop, and Demis Hassabis. The forget-me-not process. In NIPS, 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy ´ reinforcement learning. In NIPS, 2016.
+
+Brendan O’Donoghue, Remi Munos, Koray Kavukcuoglu, and Volodymyr Mnih. Combining policy gradient and Q-learning. Preprint arXiv:1611.01626, 2016.
+
+German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. Preprint arXiv:1802.07569, 2018.
+
+Mark B Ring. Child: A first step towards continual learning. Machine Learning, 28(1):77–104, 1997.
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. Preprint arXiv:1606.04671, 2016.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. In ICLR, 2016.
+
+Jonathan Schwarz, Jelena Luketina, Wojciech M Czarnecki, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. In ICML, 2018.
+
+Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In NIPS, 2017.
+
+Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. Preprint arXiv:1611.01224, 2016.
+
+Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. In ICML, 2017.
+
+# A IMPLEMENTATION DETAILS
+
+# A.1 DISTRIBUTED SETUP
+
+Our training setup was based on that of Espeholt et al. (2018), with multiple actors and a single learner. The actors (which run on CPU) generate training examples, which are then sent to the learner. Weight updates made by the learner are propagated asynchronously to the actors. The workflows for each actor and for the learner are described below in more detail.
+
+Actor. A training episode (unroll) is generated and inserted into the actor’s buffer. Reservoir sampling is used (see further details below) if the buffer has reached its maximum capacity. The actor then samples another unroll from the buffer. The new unroll and replay unroll are both fed into a queue of examples that are read by the learner. The actor waits until its last example in the queue has been read before creating another.
+
+Learner. Each element of a batch is a pair (new unroll, replay unroll) from the queue provided by actors. Thus, the number of new unrolls and the number of replay unrolls both equal the entire batch size. Depending on the buffer utilization hyperparameter (see Figure 3), the learner uses a balance of new and replay examples, taking either the new unroll or the replay unroll from each pair. Thus, no actor contributes more than a single example to the batch (reducing the variance of batches).
+
+# A.2 NETWORK
+
+For our DMLab experiments, we used the same network as in the DMLab experiments of Espeholt et al. (2018). We selected the shallower of the models considered there (a network based on Mnih et al. (2015)), omitting the additional LSTM module used for processing textual input since none of the tasks we considered included such input. For Atari, we used the same network in Progress & Compress (Schwarz et al., 2018) (which is also based on Espeholt et al. (2018)), also copying all hyperparameters.
+
+# A.3 BUFFERS
+
+Our replay buffer stores all information necessary for the V-Trace algorithm, namely the input presented by the environment, the output logits of the network, the value function output by the network, the action taken, and the reward obtained. Leveraging the distributed setup, the buffer is split among all actors equally, so that, for example, if the total buffer size were one million across a hundred actors, then each actor would have buffer capacity of ten thousand. All buffer sizes are measured in environment frames (not in numbers of unrolls), in keeping with the $x$ -axis of our training plots.
+
+For baseline experiments, no buffer was used, while all other parameters and the network remained constant.
+
+Unless otherwise specified, the replay buffer was capped at half the number of environment frames on which the network is trained. This is by design – to show that even past the buffer capacity, replay continues to prevent catastrophic forgetting. When the buffer fills up, then new unrolls are added by reservoir sampling, so that the buffer at any given point contains a uniformly random sample of all unrolls up until the present time. Reservoir sampling is implemented as in Isele & Cosgun (2018) by having each unroll associated with a random number between 0 and 1. A threshold is initialized to 0 and rises with time so that the number of unrolls above the threshold is fixed at the capacity of the buffer. Each unroll is either stored or abandoned in its entirety; no unroll is partially stored, as this would preclude training.
+
+# A.4 TRAINING
+
+Training was conducted using V-Trace, with hyperparameters on DMLab/Atari tasks set as in Espeholt et al. (2018). Behavioral cloning loss functions $L _ { \mathrm { p o l i c y - c l o n i n g } }$ and $L _ { \mathrm { v a l u e - c l o n i n g } }$ were added in some experiments with weights of 0.01 and 0.005, respectively. The established loss functions Lpolicy-gradient, $L _ { \mathrm { v a l u e } }$ , and $L _ { \mathrm { e n t r o p y } }$ were applied with weights of 1, 0.5, and ${ \approx } 0 . 0 0 5$ , in keeping with Espeholt et al. (2018). No significant effort was made to optimize fully the hyperparameters for CLEAR.
+
+# A.5 EVALUATION
+
+We evaluate each network during training on all tasks, not simply that task on which it is currently being trained. Evaluation is performed by pools of testing actors, with a separate pool for each task in question. Each pool of testing actors asynchronously updates its weights to match those of the learner, similarly to the standard (training) actors used in our distributed learning setup. The key differences are that each testing actor (i) has no replay buffer, (ii) does not feed examples to the learner for training, (iii) runs on its designated task regardless of whether this task is the one currently in use by training actors.
+
+# A.6 EXPERIMENTS
+
+In many of our experiments, we consider tasks that change after a specified number of learning episodes. The total number of episodes is monitored by the learner, and all actors switch between tasks simultaneously at the designated point, henceforward feeding examples to the learner based on experiences on the new task (as well as replay examples). Each experiment was run independently three times; figures plot the mean performance across runs, with error bars showing the standard deviation.
+
+# B PROBE TASK WITH $100 \%$ REPLAY
+
+Our goal in this experiment was to investigate more thoroughly than Figure 3 to what extent the mixture of on- and off-policy learning is necessary, instead of pure off-policy learning, in learning new tasks swiftly. We rerun our “probe task” experiments (Section 4.5), where the DMLab task natlab varying map randomized is presented at different positions in a cyclically repeating sequence of other DMLab tasks. In this case, however, we use CLEAR with $100 \%$ (off-policy) replay experience. We observe that, unlike in the original experiment (Figure 5), the performance obtained on the probe task natlab varying map randomized deteriorates markedly as it appears later in the sequence of tasks. For later positions in the sequence, the probe task comprises a smaller percentage of replay experience, thereby impeding purely off-policy learning. This result underlines why CLEAR uses new experience, as well as replay, to allow rapid learning of new tasks.
+
+![](images/82f14b109e25ca17227e98ed4906725dc46304c60d185fbc72358fb992cabd45.jpg)  
+Figure 7: This figure shows the same “probe task” setup as Figure 5, but with CLEAR using $100 \%$ replay experience. Performance on the probe task natlab varying map randomized decreases markedly as it appears later in the sequence of tasks, emphasizing the importance of using a blend of new experience and replay instead of $100 \%$ replay.
+
+# C FIGURES REPLOTTED ACCORDING TO CUMULATIVE SUM
+
+In this section, we replot the results of our main experiments, so that the $y$ -axis shows the mean cumulative reward obtained on each task during training; that is, the reward shown for time $t$ is the average $( 1 / t ) \sum _ { s < t } r _ { s }$ . This makes it easier to compare performance between models, though it smoothes out the individual periods of catastrophic forgetting. We also include tables comparing the values of the final cumulative rewards at the end of training.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>explore...</td><td rowspan=1 colspan=1>rooms_collect...</td><td rowspan=1 colspan=1>rooms_keys...</td></tr><tr><td rowspan=1 colspan=1>Separate</td><td rowspan=1 colspan=1>29.24</td><td rowspan=1 colspan=1>8.79</td><td rowspan=1 colspan=1>19.91</td></tr><tr><td rowspan=1 colspan=1>Simultaneous</td><td rowspan=1 colspan=1>32.35</td><td rowspan=1 colspan=1>8.81</td><td rowspan=1 colspan=1>20.56</td></tr><tr><td rowspan=1 colspan=1>Sequential (no CLEAR)</td><td rowspan=1 colspan=1>17.99</td><td rowspan=1 colspan=1>5.01</td><td rowspan=1 colspan=1>10.87</td></tr><tr><td rowspan=1 colspan=1>CLEAR (50-50 new-replay)</td><td rowspan=1 colspan=1>31.40</td><td rowspan=1 colspan=1>8.00</td><td rowspan=1 colspan=1>18.13</td></tr><tr><td rowspan=1 colspan=1>CLEAR w/o behavioral cloning</td><td rowspan=1 colspan=1>28.66</td><td rowspan=1 colspan=1>7.79</td><td rowspan=1 colspan=1>16.63</td></tr><tr><td rowspan=1 colspan=1>CLEAR, 75-25 new-replay</td><td rowspan=1 colspan=1>30.28</td><td rowspan=1 colspan=1>7.83</td><td rowspan=1 colspan=1>17.86</td></tr><tr><td rowspan=1 colspan=1>CLEAR,100% replay</td><td rowspan=1 colspan=1>31.09</td><td rowspan=1 colspan=1>7.48</td><td rowspan=1 colspan=1>13.39</td></tr><tr><td rowspan=1 colspan=1>CLEAR,buffer5M</td><td rowspan=1 colspan=1>30.33</td><td rowspan=1 colspan=1>8.00</td><td rowspan=1 colspan=1>18.07</td></tr><tr><td rowspan=1 colspan=1>CLEAR,buffer 50M</td><td rowspan=1 colspan=1>30.82</td><td rowspan=1 colspan=1>7.99</td><td rowspan=1 colspan=1>18.21</td></tr></table>
+
+![](images/daf0d1b74b06e2d16d0138065bacc4f9791038986d3ee878f871910f54e23e89.jpg)  
+Figure 8: Quantitative comparison of the final cumulative performance between standard training (“Sequential (no CLEAR)”) and various versions of CLEAR (see Figures 9, 10, 11, and 12 below) on a cyclically repeating sequence of DMLab tasks. We also include the results of training on each individual task with a separate network (“Separate”) and on all tasks simultaneously (“Simultaneous”) instead of sequentially. As described in Section 4.1, these situations represent no-forgetting scenarios and thus present upper bounds on the performance expected in a continual learning setting, where tasks are presented sequentially. Remarkably, CLEAR achieves performance comparable to “Separate” and “Simultaneous”, demonstrating that forgetting is virtually eliminated.   
+Figure 9: Alternative plot of the experiments shown in Figure 1, showing the difference in cumulative performance between training on tasks separately, simultaneously, and sequentially (without using CLEAR). The marked decrease in performance for sequential training is due to catastrophic forgetting. As in our earlier plots, thicker line segments are used to denote times at which the network is gaining new experience on a given task.
+
+![](images/55261fe95d499a1663f48d11348a53227eaf6ce98736d360b1b76681ea545d05.jpg)  
+Figure 10: Alternative plot of the experiments shown in Figure 2, showing how applying CLEAR when training on sequentially presented tasks gives almost the same results as training on all tasks simultaneously (compare to sequential and simultaneous training in Figure 9 above). Applying CLEAR without behavioral cloning also yields decent results.
+
+![](images/11d8ea8904016133e59f70f61c531a020561649bb8bbff91bee61ea8e356d851.jpg)  
+Figure 11: Alternative plot of the experiments shown in Figure 3, comparing performance between using CLEAR with 75-25 new-replay experience, 50-50 new-replay experience, and $100 \%$ replay experience. An equal balance of new and replay experience seems to represent a good tradeoff between stability and plasticity, while $100 \%$ replay reduces forgetting but lowers performance overall.
+
+![](images/66269e241cd72c0f9e2fb3fbc361e24ce26e1033433b84119dd340560205801a.jpg)  
+Figure 12: Alternative plot of the experiments shown in Figure 4, showing that reduced-size buffers still allow CLEAR to achieve essentially the same performance.
+
+Figure 13: Quantitative comparison of the final cumulative performance between baseline (standard training), CLEAR, Elastic Weight Consolidation (EWC), and Progress & Compress (P&C) (see Figure 14 below). Overall, CLEAR performs comparably to or better than P&C, and significantly better than EWC and baseline.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>space_invaders</td><td rowspan=1 colspan=1>krull</td><td rowspan=1 colspan=1>beam_rider</td><td rowspan=1 colspan=1>hero</td><td rowspan=1 colspan=1>star-gunner</td><td rowspan=1 colspan=1>ms-pacman</td></tr><tr><td rowspan=1 colspan=1>Baseline</td><td rowspan=1 colspan=1>346.47</td><td rowspan=1 colspan=1>5512.36</td><td rowspan=1 colspan=1>952.72</td><td rowspan=1 colspan=1>2737.32</td><td rowspan=1 colspan=1>1065.20</td><td rowspan=1 colspan=1>753.83</td></tr><tr><td rowspan=1 colspan=1>CLEAR</td><td rowspan=1 colspan=1>426.72</td><td rowspan=1 colspan=1>8845.12</td><td rowspan=1 colspan=1>585.05</td><td rowspan=1 colspan=1>8106.22</td><td rowspan=1 colspan=1>991.74</td><td rowspan=1 colspan=1>1222.82</td></tr><tr><td rowspan=1 colspan=1>EWC</td><td rowspan=1 colspan=1>549.22</td><td rowspan=1 colspan=1>5352.92</td><td rowspan=1 colspan=1>432.78</td><td rowspan=1 colspan=1>4499.35</td><td rowspan=1 colspan=1>704.20</td><td rowspan=1 colspan=1>639.75</td></tr><tr><td rowspan=1 colspan=1>P&amp;C</td><td rowspan=1 colspan=1>455.34</td><td rowspan=1 colspan=1>7025.40</td><td rowspan=1 colspan=1>743.38</td><td rowspan=1 colspan=1>3433.10</td><td rowspan=1 colspan=1>1261.86</td><td rowspan=1 colspan=1>924.52</td></tr></table>
+
+![](images/e69e52e550d426a64e883ac2eee1eabc869e4fe44e4b41fe0eb0b5704c777283.jpg)  
+Figure 14: Alternative plot of the experiments shown in Figure 6, showing that CLEAR attains comparable or better performance than the more complicated methods Progress & Compress (P&C) and Elastic Weight Consolidation (EWC), which also require information about task boundaries, unlike CLEAR.

parse/train/S1g2V3Cct7/S1g2V3Cct7_content_list.json

@@ -0,0 +1,1414 @@
+[
+    {
+        "type": "text",
+        "text": "EXPERIENCE REPLAY FOR CONTINUAL LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            101,
+            769,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            400,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Continual learning is the problem of learning new tasks or knowledge while protecting old knowledge and ideally generalizing from old experience to learn new tasks faster. Neural networks trained by stochastic gradient descent often degrade on old tasks when trained successively on new tasks with different data distributions. This phenomenon, referred to as catastrophic forgetting, is considered a major hurdle to learning with non-stationary data or sequences of new tasks, and prevents networks from continually accumulating knowledge and skills. We examine this issue in the context of reinforcement learning, in a setting where an agent is exposed to tasks in a sequence. Unlike most other work, we do not provide an explicit indication to the model of task boundaries, which is the most general circumstance for a learning agent exposed to continuous experience. While various methods to counteract catastrophic forgetting have recently been proposed, we explore a straightforward, general, and seemingly overlooked solution – that of using experience replay buffers for all past events – with a mixture of on- and off-policy learning, leveraging behavioral cloning. We show that this strategy can still learn new tasks quickly yet can substantially reduce catastrophic forgetting in both Atari and DMLab domains, even matching the performance of methods that require task identities. When buffer storage is constrained, we confirm that a simple mechanism for randomly discarding data allows a limited size buffer to perform almost as well as an unbounded one. ",
+        "bbox": [
+            233,
+            237,
+            764,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            336,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modern day reinforcement learning (RL) has benefited substantially from a massive influx of computational resources. In some instances, the number of data points to feed into RL algorithms has kept in step with computational feasibility. For example, in simulation environments or in self-play RL, it is possible to generate fresh data on the fly. In such settings, the continual learning problem (Ring, 1997) is often ignored because new experiences can be collected on demand, and the start states of the simulation can be controlled. When training on multiple tasks, it is possible to train on all environments simultaneously within the same data batch. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            665
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As RL is increasingly applied to problems in industry or other real-world settings, however, it is necessary to consider cases, such as robotics, where gathering new experience is expensive or difficult. In such examples, simultaneous training may be infeasible. Instead, an agent must be able to learn from only one task at a time. The time spent on different tasks and the sequence in which those tasks occur are not under the control of the agent. The boundaries between tasks, in fact, will often be unknown – or tasks will deform continuously and not have definite boundaries at all. Such a paradigm for training eliminates the possibility of simultaneously acting upon and learning from several tasks, and leads to the danger of catastrophic forgetting, wherein an agent forgets what it has learned previously when it encounters a new situation. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Here, we consider the setting of reinforcement learning where compute and memory resources are large, but the environment is not stationary: this may arise because an RL agent is encountering a task curriculum or sequence of unrelated tasks, engaged in a budgeted physical interaction within a robot, or learning from unstructured interaction with humans. In this setting, the problem of continual learning rears its head: the distribution over experiences is not controlled to facilitate the agent’s maintenance of previously acquired ability. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An ideal continual learning system should meet three requirements. First, it should retain previously learned capacities. When a previously encountered task or situation is encountered, performance should immediately be good – ideally as good as it was historically. Second, maintenance of old skills or knowledge should not inhibit further rapid acquisition of a new skill or knowledge. These two simultaneous constraints – maintaining the old while still adapting to the new – represent the challenge known as the stability-plasticity dilemma Grossberg (1982). Third, where possible, a continual learning system should learn new skills that are related to old ones faster than it would have de novo, a property known as constructive interference or positive transfer. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/2f2e8e397f02c2fb4e044236788ce53437ac3519732f819028385a81cf923fc9.jpg",
+        "image_caption": [
+            "Figure 1: Separate, simultaneous, and sequential training: the $x$ -axis denotes environment steps summed across all tasks and the $y$ -axis episode score. In “Sequential”, thick line segments are used to denote the task currently being trained, while thin segments are plotted by evaluating performance without learning. In simultaneous training, performance on explore object locations small is higher than in separate training, an example of modest constructive interference. In sequential training, tasks that are not currently being learned exhibit very dramatic catastrophic forgetting. (See Appendix C for a different plot of these data.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            101,
+            818,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            364,
+            825,
+            448
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We here demonstrate the surprising power of a simple approach: Continual Learning with Experience And Replay (CLEAR). We show that training a network on a mixture of novel experience on-policy and replay experience off-policy allows for both maintenance of performance on earlier tasks and fast adaptation to new tasks. A significant further boost in performance and reduction in catastrophic forgetting is obtained by enforcing behavioral cloning between the current policy and its past self. While memory is rarely severely limited in modern RL, we show that small replay buffers filled with uniform samples from past experiences can be almost as effective as buffers of unbounded size. When comparing CLEAR against state-of-the-art approaches for reducing catastrophic forgetting, we obtain better or comparable results, despite the relative simplicity of our approach; yet, crucially, CLEAR requires no information about the identity of tasks or boundaries between them. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            339,
+            635
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The problem of catastrophic forgetting in neural networks has long been recognized (Grossberg, 1982), and it is known that rehearsing past data can be a satisfactory antidote for some purposes (McClelland, 1998; French, 1999). Consequently, in the supervised setting that is the most common paradigm in machine learning, catastrophic forgetting has been accorded less attention than in cognitive science or neuroscience, since a fixed dataset can be reordered and replayed as necessary to ensure high performance on all samples. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In recent years, however, there has been renewed interest in overcoming catastrophic forgetting in RL contexts and in supervised learning from streaming data (Parisi et al., 2018). Current strategies for mitigating catastrophic forgetting have primarily focused on schemes for protecting the parameters inferred in one task while training on another. For example, in Elastic Weight Consolidation (EWC) (Kirkpatrick et al., 2017), weights important for past tasks are constrained to change more slowly while learning new tasks. The Progressive Networks approach (Rusu et al., 2016) freezes subnetworks trained on individual tasks, and Progress & Compress (Schwarz et al., 2018) uses EWC to consolidate the network after each task has been learned. Kaplanis et al. (2018) treat individual synaptic weights as dynamical systems with latent dimensions / states that protect information. Outside of RL, Zenke et al. (2017) develop a method similar to EWC that maintains estimates of the importance of weights for past tasks, Li & Hoiem (2017) leverage a mixture of task-specific and shared parameters, and Milan et al. (2016) develop a rigorous Bayesian approach for estimating unknown task boundaries. Notably all these methods assume that task identities or boundaries are known, with the exception of Milan et al. (2016), for which the approach is likely not scalable to highly complex tasks. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb086f3d51af01fdad811ec99b216226b67686d5eb249644ae8e52beb016326d.jpg",
+        "image_caption": [
+            "Figure 2: Demonstration of CLEAR on three DMLab tasks, which are trained cyclically in sequence. CLEAR reduces catastrophic forgetting so significantly that sequential tasks train almost as well as simultaneous tasks (see Figure 1). When the behavioral cloning loss terms are ablated, there is still reduced forgetting from off-policy replay alone. As above, thicker line segments are used to denote the task that is currently being trained. (See Appendix C for a different plot of these data.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            102,
+            787,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            375,
+            823,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Rehearsing old data via experience replay buffers is a common technique in RL. However, their introduction has primarily been driven by the goal of data-efficient learning on single tasks (Lin, 1992; Mnih et al., 2015; Gu et al., 2017). Research in this vein has included prioritized replay for maximizing the impact of rare experiences (Schaul et al., 2016), learning from human demonstration data seeded into a buffer (Hester et al., 2017), and methods for approximating replay buffers with generative models (Shin et al., 2017). A noteworthy use of experience replay buffers to protect against catastrophic forgetting was demonstrated in Isele & Cosgun (2018) on toy tasks, with a focus on how buffers can be made smaller. Previous works (Gu et al., 2017; O’Donoghue et al., 2016; Wang et al., 2016) have explored mixing on- and off-policy updates in RL, though these were focused on speed and stability in individual tasks and did not examine continual learning. Here, in CLEAR, we demonstrate that a mixture of replay data and fresh experience protects against catastrophic forgetting while also permitting fast learning, and performs better than either pure onpolicy learning or pure off-policy learning from replay. We provide a thorough investigation and robust algorithm in CLEAR, conducting a wide variety of tests on both limited-size and unbounded buffers with complex RL tasks using state-of-the-art methods, and improve the stability of simple replay with the addition of behavioral cloning. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE CLEAR METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            397,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CLEAR uses actor-critic training on a mixture of new and replayed experiences. In the case of replay experiences, two additional loss terms are added to induce behavioral cloning between the network and its past self. The motivation for behavioral cloning is to prevent network output on replayed tasks from drifting while learning new tasks. We penalize (1) the KL divergence between the historical policy distribution and the present policy distribution, (2) the L2 norm of the difference between the historical and present value functions. Formally, this corresponds to adding the following loss functions, defined with respect to network parameters $\\theta$ : ",
+        "bbox": [
+            173,
+            683,
+            825,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/722071632787613360aeee67893a569bed2393f56ff00aa91b67ca3cd8eaeea0.jpg",
+        "text": "$$\nL _ { \\mathrm { p o l i c y - c l o n i n g } } : = \\sum _ { a } \\mu ( a | h _ { s } ) \\log { \\frac { \\mu ( a | h _ { s } ) } { \\pi _ { \\theta } ( a | h _ { s } ) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            785,
+            638,
+            823
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0a615b6330c6585667ad4ffecf7159af54efab6066ea861ea6dfbc6a0e8d07d.jpg",
+        "text": "$$\nL _ { \\mathrm { v a l u e - c l o n i n g } } : = | | V _ { \\theta } ( h _ { s } ) - V _ { \\mathrm { r e p l a y } } ( h _ { s } ) | | _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            827,
+            630,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\pi _ { \\theta }$ denotes the (current) policy of the network over actions $a , \\mu$ the policy generating the observed experience, and $h _ { s }$ the hidden state of the network at time $s$ . Note that computing $\\bar { \\mathrm { K L } } [ \\mu | | \\pi _ { \\theta } ]$ instead of $\\operatorname { K L } [ \\pi _ { \\boldsymbol { \\theta } } | | \\mu ]$ ensures that $\\pi _ { \\boldsymbol { \\theta } } ( a | h _ { s } )$ is nonzero wherever the historical policy is as well. ",
+        "bbox": [
+            174,
+            847,
+            823,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We apply CLEAR in a distributed training context based on the Importance Weighted Actor-Learner Architecture (Espeholt et al., 2018). A single learning network is fed experiences (both novel and ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/2eafc7a1ca6c7c1be52871ecd3f8172b22ac53af14a7311a7911455d3b0ff395.jpg",
+        "image_caption": [
+            "Figure 3: Comparison between different proportions of new and replay examples while cycling training among three tasks. We observe that with a 75-25 new-replay split, CLEAR eliminates most, but not all, catastrophic forgetting. At the opposite extreme, $100 \\%$ replay prevents forgetting at the expense of reduced overall performance (with an especially noticeable reduction in early performance on the task rooms keys doors puzzle). A 50-50 split represents a good tradeoff between these extremes. (See Appendix C for a different plot of these data.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            818,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "replay) by a number of acting networks, for which the weights are asynchronously updated to match those of the learner. The network architecture and hyperparameters are chosen as in Espeholt et al. (2018). Training proceeds according to V-Trace. Namely, define the V-Trace target $v _ { s }$ by: ",
+        "bbox": [
+            173,
+            344,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67625f7e8ac49b73e4749ff69a2897557253f7849c50352afb05000bbbfe98a3.jpg",
+        "text": "$$\nv _ { s } : = V ( h _ { s } ) + \\sum _ { t = s } ^ { s + n - 1 } \\gamma ^ { t - s } \\left( \\prod _ { i = s } ^ { t - 1 } c _ { i } \\right) \\delta _ { t } V ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            392,
+            638,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta _ { t } V : = \\rho _ { t } \\left( r _ { t } + \\gamma V ( h _ { t + 1 } ) - V ( h _ { t } ) \\right)$ , $\\begin{array} { r } { c _ { i } : = \\operatorname* { m i n } ( \\bar { c } , \\frac { \\pi _ { \\theta } ( a _ { i } | h _ { i } ) } { \\mu ( a _ { i } | h _ { i } ) } ) } \\end{array}$ , and $\\begin{array} { r } { \\rho _ { t } = \\operatorname* { m i n } ( \\bar { \\rho } , \\frac { \\pi _ { \\theta } ( a _ { t } | h _ { t } ) } { \\mu ( a _ { t } | h _ { t } ) } ) } \\end{array}$ , for constants $\\bar { c }$ and $\\bar { \\rho }$ . ",
+        "bbox": [
+            174,
+            440,
+            823,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then, the value function update is given by the L2 loss: ",
+        "bbox": [
+            174,
+            481,
+            539,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11eff35a91fc8179e708067f165760d4cb3dd60659e94d1b12f361e55f8ce4e5.jpg",
+        "text": "$$\nL _ { \\mathrm { v a l u e } } : = \\left( V _ { \\theta } ( h _ { s } ) - v _ { s } \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            500,
+            586,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The policy gradient loss is: ",
+        "bbox": [
+            174,
+            531,
+            352,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/565f3c47d4e1fcb3e0d9dbde605e5806e3e49511ebd8efc6b3c411831902c43d.jpg",
+        "text": "$$\n\\begin{array} { r } { L _ { \\mathrm { p o l i c y - g r a d i e n t } } : = - \\rho _ { s } \\log \\pi _ { \\theta } ( a _ { s } | h _ { s } ) \\left( r _ { s } + \\gamma v _ { s + 1 } - V _ { \\theta } ( h _ { s } ) \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            551,
+            696,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We also use an entropy loss: ",
+        "bbox": [
+            174,
+            580,
+            361,
+            594
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72ea22c9b0c70b6a2898fffb241bb9e0c9b41f290233849cb404079ef851e1fd.jpg",
+        "text": "$$\nL _ { \\mathrm { e n t r o p y } } : = \\sum _ { a } \\pi _ { \\theta } ( a | h _ { s } ) \\log \\pi _ { \\theta } ( a | h _ { s } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            599,
+            624,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The loss functions $L _ { \\mathrm { v a l u e } }$ , $L _ { \\mathrm { p o l i c y - g r a d i e n t } }$ , and $L _ { \\mathrm { e n t r o p y } }$ are applied both for new and replay experiences. In addition, we add $L _ { \\mathrm { p o l i c y - c l o n i n g } }$ and $L _ { \\mathrm { v a l u e - c l o n i n g } }$ for replay experiences only. In general, our experiments use a 50-50 mixture of novel and replay experiences, though performance does not appear to be very sensitive to this ratio. Further implementation details are given in Appendix A. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            282,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 CATASTROPHIC FORGETTING VS. INTERFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            752,
+            553,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our first experiment (Figure 1) was designed to distinguish between two distinct concepts that are sometimes conflated, interference and catastrophic forgetting, and to emphasize the outsized role of the latter as compared to the former. Interference occurs when two or more tasks are incompatible (destructive interference) or mutually helpful (constructive interference) within the same model. Catastrophic forgetting occurs when a task’s performance goes down not as a result of incompatibility with another task but as a result of the second task overwriting it within the model. As we aim to illustrate, the two are independent phenomena, and while interference may happen, forgetting is ubiquitous. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We considered a set of three distinct tasks within the DMLab set of environments (Beattie et al., 2016), and compared three training paradigms on which a network may be trained to perform these three tasks: (1) Training networks on the individual tasks separately, (2) training a single network examples from all tasks simultaneously (which permits interference among tasks), and (3) training a single network sequentially on examples from one task, then the next task, and so on cyclically. Across all training protocols, the total amount of experience for each task was held constant. Thus, for separate networks training on separate tasks, the $x$ -axis in our plots shows the total number of environment frames summed across all tasks. For example, at three million frames, one million were on task 1, one million on task 2, and one million on task 3. This allows a direct comparison to simultaneous training, in which the same network was trained on all three tasks. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/47e101294e49148bab9ed0b66dd2d526575f7c469e3b5ebf880e5002a42edafe.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of the performance of training with different buffer sizes, using reservoir sampling to ensure that each buffer stores a uniform sample from all past experience. We observe only minimal difference in performance, with the smallest buffer (storing 1 in 200 experiences) demonstrating some catastrophic forgetting. (See Appendix C for a different plot of these data.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            818,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            323,
+            825,
+            434
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We observe that in DMLab, there is very little difference between separate and simultaneous training. This indicates minimal interference between tasks. If anything, there is a small amount of constructive interference, with simultaneous training performing slightly better than separate training. We assume this is a result of (i) commonalities in image processing required across different tasks, and (ii) certain basic exploratory behaviors, e.g., moving around, that are advantageous across tasks. (By contrast, destructive interference might result from incompatible behaviors or from insufficient model capacity.) ",
+        "bbox": [
+            174,
+            441,
+            825,
+            540
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By contrast, there is a large difference between either of the above modes of training and sequential training, where performance on a task decays immediately when training switches to another task – that is, catastrophic forgetting. Note that the performance of the sequential training appears at some points to be greater than that of separate training. This is purely because in sequential training, training proceeds exclusively on a single task, then exclusively on another task. For example, the first task quickly increases in performance since the network is effectively seeing three times as much data on that task as the networks training on separate or simultaneous tasks. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 CLEAR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            271,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We here demonstrate the efficacy of CLEAR for diminishing catastrophic forgetting (Figure 2). We apply CLEAR to the cyclically repeating sequence of DMLab tasks used in the preceding experiment. Our method effectively eliminates forgetting on all three tasks, while preserving overall training performance (see “Sequential” training in Figure 1 for reference). When the task switches, there is little, if any, dropoff in performance when using CLEAR, and the network picks up immediately where it left off once a task returns later in training. Without behavioral cloning, the mixture of new experience and replay still reduces catastrophic forgetting, though the effect is reduced. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 BALANCE OF ON- AND OFF-POLICY LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            813,
+            537,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this experiment (Figure 3), we consider the ratio of new examples to replay examples during training. Using $100 \\%$ new examples is simply standard training, which as we have seen is subject to dramatic catastrophic forgetting. At 75-25 new-replay, there is already significant resistance to forgetting. At the opposite extreme, $100 \\%$ replay examples is extremely resistant to catastrophic forgetting, but at the expense of a (slight) decrease in performance attained. We believe that 50- 50 new-replay represents a good tradeoff, combining significantly reduced catastrophic forgetting with no appreciable decrease in performance attained. Unless otherwise stated, our experiments on CLEAR will use a 50-50 split of new and replay data in training. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6218075b072f0c8049d2f1132cb0160eb8889f9b62be607d20a1da603c7a9047.jpg",
+        "image_caption": [
+            "Figure 5: The DMLab task natlab varying map randomize (brown line) is presented at different positions within a cyclically repeating sequence of three other DMLab tasks. We find that (1) performance on the probe task is independent of its position in the sequence, (2) the effectiveness of CLEAR does not degrade as more experiences and tasks are introduced into the buffer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            97,
+            818,
+            587
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            688,
+            823,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is notable that it is possible to train purely on replay examples, since the network has essentially no on-policy learning. In fact, the figure shows that with $100 \\%$ replay, performance on each task increases throughout, even when on-policy learning is being applied to a different task. Just as Figure 2 shows the importance of behavioral cloning for maintaining past performance on a task, so this experiment shows that off-policy learning can actually increase performance from replay alone. Both ingredients are necessary for the success of CLEAR. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 LIMITED-SIZE BUFFERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            379,
+            840
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In some cases, it may be impractical to store all past experiences in the replay buffer. We therefore test the efficacy of buffers that have capacity for only a relatively small number of experiences (Figure 4). Once the buffer is full, we use reservoir sampling to decide when to replace elements of the buffer with new experiences (Isele & Cosgun, 2018) (see details in Appendix A). Thus, at each point in time, the buffer contains a (fixed size) sample uniformly at random of all past experiences. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider a sequence of tasks with 900 million environmental frames, comparing a large buffer of capacity 450 million to two small buffers of capacity 5 and 50 million. We find that all buffers perform well and conclude that it is possible to learn and reduce catastrophic forgetting even with a replay buffer that is significantly smaller than the total number of experiences. Decreasing the buffer size to 5 million results in a slight decrease in robustness to catastrophic forgetting. This may be due to over-fitting to the limited examples present in the buffer, on which the learner trains disproportionately often. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 LEARNING A NEW TASK QUICKLY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            218,
+            444,
+            232
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is a reasonable worry that relying on a replay buffer could cause new tasks to be learned more slowly as the new task data will make up a smaller and smaller portion of the replay buffer as the buffer gets larger. In this experiment (Figure 5), we find that this is not a problem for CLEAR, relying as it does on a mixture of off- and on-policy learning. Specifically, we find the performance attained on a task is largely independent of the amount of data stored in the buffer and on the identities of the preceding tasks. We consider a cyclically repeating sequence of three DMLab tasks. At different points in the sequence, we insert a fourth DMLab task as a “probe”. We find that the performance attained on the probe task is independent of the point at which it is introduced within the training sequence. This is true both for normal training and for CLEAR. Notably, CLEAR succeeds in greatly reducing catastrophic forgetting for all tasks, and the effect on the probe task does not diminish as the probe task is introduced later on in the training sequence. See also Appendix B for an experiment demonstrating that pure off-policy learning performs quite differently in this setting. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.6 COMPARISON TO P&C AND EWC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            447,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we compare our method to Progress & Compress (P&C) (Schwarz et al., 2018) and Elastic Weight Consolidation (EWC) (Kirkpatrick et al., 2017), state-of-the-art methods for reducing catastrophic forgetting that, unlike replay, assume that the boundaries between different tasks are known (Figure 6). We use exactly the same sequence of Atari tasks as the authors of P&C (Schwarz et al., 2018), with the same time spent on each task. Likewise, the network and hyperparameters we use are designed to match exactly those used in Schwarz et al. (2018). This is simplified by the authors of P&C also using a training paradigm based on that in Espeholt et al. (2018). In this case, we use CLEAR with a 75-25 balance of new-replay experience. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find that we obtain comparable performance to P&C and better performance than EWC, despite CLEAR being significantly simpler and agnostic to the boundaries between tasks. On tasks krull, hero, and ms pacman, we obtain significantly higher performance than P&C (as well as EWC), while on beam rider and star gunner, P&C obtains higher performance. It is worth noting that though the on-policy model (baseline) experiences significant catastrophic forgetting, it also rapidly re-acquires its previous performance after re-exposure to the task; this allows baseline to be cumulatively better than EWC on some tasks (as is noted in the original paper Kirkpatrick et al. (2017)). An alternative plot of this experiment, showing cumulative performance on each task, is presented in Appendix C. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            698
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            310,
+            733
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Some version of replay is believed to be present in biological brains. We do not believe that our implementation is reflective of neurobiology, though there are potential connections; hippocampal replay has been proposed as a systems-level mechanism to reduce catastrophic forgetting and improve generalization as in the theory of complementary learning systems (McClelland, 1998). This contrasts to some degree with synapse-level consolidation, which is also believed to be present in biology (Benna & Fusi, 2016), but is more like continual learning methods that protect parameters. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Indeed, algorithms for continual learning may live on a Pareto frontier: different methods may have different regimes of applicability. In cases for which storing a large memory buffer is truly prohibitive, methods that protect inferred parameters, such as Progress & Compress, may be more suitable than replay methods. When task identities are available or boundaries between tasks are very clear, leveraging this information may reduce memory or computational demands or be useful to alert the agent to engage in rapid learning. Further, there exist training scenarios that are adversarial either to our method or to any method that prevents forgetting. For example, if the action space of a task were changed during training, fitting to the old policy’s action distribution, whether through behavioral cloning, off-policy learning, weight protection, or any of a number of other strategies for preventing catastrophic forgetting, could have a deleterious effect on future performance. For such cases, we may need to develop algorithms that selectively protect skills as well as forget them. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a16653237c5e89a85928694b32a4fd98d9904a59816efa45cd016632315b34c.jpg",
+        "image_caption": [
+            "Figure 6: Comparison of CLEAR to Progress & Compress (P&C) and Elastic Weight Consolidation (EWC). We find that CLEAR demonstrates comparable or greater performance than these methods, despite being significantly simpler and not requiring any knowledge of boundaries between tasks. (See Appendix C for a different plot of these data.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            102,
+            751,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have explored CLEAR in a range of continual learning scenarios; we hope that some of the experimental protocols, such as probing with a novel task at varied positions in a training sequence, may inspire other research. Moving forward, we anticipate many algorithmic innovations that build on the ideas set forward here. For example, weight-consolidation techniques such as Progress & Compress are quite orthogonal to our approach and could be married with it for further performance gains. Moreover, while the V-Trace algorithm we use is effective at off-policy correction for small shifts between the present and past policy distributions, it is possible that off-policy approaches leveraging Q-functions, such as Retrace (Munos et al., 2016), may prove more powerful still. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have described a simple but powerful approach for preventing catastrophic forgetting in continual learning settings. CLEAR uses on-policy learning on fresh experiences to adapt rapidly to new tasks, while using off-policy learning with behavioral cloning on replay experience to maintain and modestly enhance performance on past tasks. Behavioral cloning on replay data further enhances the agent’s stability. Our method is simple, scalable, and practical; it takes advantage of the general abundance of memory and storage in modern computers and computing facilities. We believe that the broad applicability and simplicity of the approach make CLEAR a candidate “first line of defense” against catastrophic forgetting in many RL contexts. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler, ¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. DeepMind Lab. ´ Preprint arXiv:1612.03801, 2016. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcus K Benna and Stefano Fusi. Computational principles of synaptic memory consolidation. Nature neuroscience, 19(12):1697, 2016. ",
+        "bbox": [
+            168,
+            176,
+            821,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymir Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. IMPALA: Scalable distributed Deep-RL with importance weighted actor-learner architectures. In ICML, 2018. ",
+        "bbox": [
+            176,
+            213,
+            823,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3(4):128–135, 1999. ",
+        "bbox": [
+            171,
+            265,
+            823,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stephen Grossberg. How does a brain build a cognitive code? In Studies of mind and brain, pp. 1–52. Springer, 1982. ",
+        "bbox": [
+            171,
+            303,
+            823,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Tim Lillicrap, Richard E Turner, Zoubin Ghahramani, Bernhard Scholkopf, and Sergey ¨ Levine. Interpolated policy gradient: Merging on-policy and off-policy gradient estimation for deep reinforcement learning. In NIPS, 2017. ",
+        "bbox": [
+            174,
+            339,
+            823,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Gabriel Dulac-Arnold, et al. Deep Q-learning from demonstrations. Preprint arXiv:1704.03732, 2017. ",
+        "bbox": [
+            176,
+            390,
+            823,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Isele and Akansel Cosgun. Selective experience replay for lifelong learning. In AAAI, 2018. ",
+        "bbox": [
+            171,
+            441,
+            821,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christos Kaplanis, Murray Shanahan, and Claudia Clopath. Continual reinforcement learning with complex synapses. Preprint arXiv:1802.07239, 2018. ",
+        "bbox": [
+            171,
+            465,
+            823,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. In Proceedings of the National Academy of Sciences, 2017. ",
+        "bbox": [
+            173,
+            502,
+            825,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2017. ",
+        "bbox": [
+            171,
+            568,
+            823,
+            598
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Long-Ji Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine learning, 8(3-4):293–321, 1992. ",
+        "bbox": [
+            171,
+            606,
+            821,
+            635
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James L McClelland. Complementary learning systems in the brain: A connectionist approach to explicit and implicit cognition and memory. Annals of the New York Academy of Sciences, 843 (1):153–169, 1998. ",
+        "bbox": [
+            171,
+            643,
+            823,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kieran Milan, Joel Veness, James Kirkpatrick, Michael Bowling, Anna Koop, and Demis Hassabis. The forget-me-not process. In NIPS, 2016. ",
+        "bbox": [
+            176,
+            694,
+            821,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015. ",
+        "bbox": [
+            173,
+            732,
+            825,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy ´ reinforcement learning. In NIPS, 2016. ",
+        "bbox": [
+            174,
+            782,
+            821,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Brendan O’Donoghue, Remi Munos, Koray Kavukcuoglu, and Volodymyr Mnih. Combining policy gradient and Q-learning. Preprint arXiv:1611.01626, 2016. ",
+        "bbox": [
+            174,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. Preprint arXiv:1802.07569, 2018. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mark B Ring. Child: A first step towards continual learning. Machine Learning, 28(1):77–104, 1997. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. Preprint arXiv:1606.04671, 2016. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            156,
+            821,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Schwarz, Jelena Luketina, Wojciech M Czarnecki, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. In ICML, 2018. ",
+        "bbox": [
+            173,
+            195,
+            825,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            250,
+            823,
+            279
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. Preprint arXiv:1611.01224, 2016. ",
+        "bbox": [
+            173,
+            289,
+            823,
+            332
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. In ICML, 2017. ",
+        "bbox": [
+            173,
+            343,
+            821,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            400,
+            436,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.1 DISTRIBUTED SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            362,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our training setup was based on that of Espeholt et al. (2018), with multiple actors and a single learner. The actors (which run on CPU) generate training examples, which are then sent to the learner. Weight updates made by the learner are propagated asynchronously to the actors. The workflows for each actor and for the learner are described below in more detail. ",
+        "bbox": [
+            174,
+            458,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Actor. A training episode (unroll) is generated and inserted into the actor’s buffer. Reservoir sampling is used (see further details below) if the buffer has reached its maximum capacity. The actor then samples another unroll from the buffer. The new unroll and replay unroll are both fed into a queue of examples that are read by the learner. The actor waits until its last example in the queue has been read before creating another. ",
+        "bbox": [
+            174,
+            521,
+            823,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Learner. Each element of a batch is a pair (new unroll, replay unroll) from the queue provided by actors. Thus, the number of new unrolls and the number of replay unrolls both equal the entire batch size. Depending on the buffer utilization hyperparameter (see Figure 3), the learner uses a balance of new and replay examples, taking either the new unroll or the replay unroll from each pair. Thus, no actor contributes more than a single example to the batch (reducing the variance of batches). ",
+        "bbox": [
+            174,
+            598,
+            825,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.2 NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            290,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For our DMLab experiments, we used the same network as in the DMLab experiments of Espeholt et al. (2018). We selected the shallower of the models considered there (a network based on Mnih et al. (2015)), omitting the additional LSTM module used for processing textual input since none of the tasks we considered included such input. For Atari, we used the same network in Progress & Compress (Schwarz et al., 2018) (which is also based on Espeholt et al. (2018)), also copying all hyperparameters. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.3 BUFFERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            282,
+            828
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our replay buffer stores all information necessary for the V-Trace algorithm, namely the input presented by the environment, the output logits of the network, the value function output by the network, the action taken, and the reward obtained. Leveraging the distributed setup, the buffer is split among all actors equally, so that, for example, if the total buffer size were one million across a hundred actors, then each actor would have buffer capacity of ten thousand. All buffer sizes are measured in environment frames (not in numbers of unrolls), in keeping with the $x$ -axis of our training plots. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For baseline experiments, no buffer was used, while all other parameters and the network remained constant. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Unless otherwise specified, the replay buffer was capped at half the number of environment frames on which the network is trained. This is by design – to show that even past the buffer capacity, replay continues to prevent catastrophic forgetting. When the buffer fills up, then new unrolls are added by reservoir sampling, so that the buffer at any given point contains a uniformly random sample of all unrolls up until the present time. Reservoir sampling is implemented as in Isele & Cosgun (2018) by having each unroll associated with a random number between 0 and 1. A threshold is initialized to 0 and rises with time so that the number of unrolls above the threshold is fixed at the capacity of the buffer. Each unroll is either stored or abandoned in its entirety; no unroll is partially stored, as this would preclude training. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.4 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            281,
+            289,
+            295
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Training was conducted using V-Trace, with hyperparameters on DMLab/Atari tasks set as in Espeholt et al. (2018). Behavioral cloning loss functions $L _ { \\mathrm { p o l i c y - c l o n i n g } }$ and $L _ { \\mathrm { v a l u e - c l o n i n g } }$ were added in some experiments with weights of 0.01 and 0.005, respectively. The established loss functions Lpolicy-gradient, $L _ { \\mathrm { v a l u e } }$ , and $L _ { \\mathrm { e n t r o p y } }$ were applied with weights of 1, 0.5, and ${ \\approx } 0 . 0 0 5$ , in keeping with Espeholt et al. (2018). No significant effort was made to optimize fully the hyperparameters for CLEAR. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.5 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            407,
+            310,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We evaluate each network during training on all tasks, not simply that task on which it is currently being trained. Evaluation is performed by pools of testing actors, with a separate pool for each task in question. Each pool of testing actors asynchronously updates its weights to match those of the learner, similarly to the standard (training) actors used in our distributed learning setup. The key differences are that each testing actor (i) has no replay buffer, (ii) does not feed examples to the learner for training, (iii) runs on its designated task regardless of whether this task is the one currently in use by training actors. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            318,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In many of our experiments, we consider tasks that change after a specified number of learning episodes. The total number of episodes is monitored by the learner, and all actors switch between tasks simultaneously at the designated point, henceforward feeding examples to the learner based on experiences on the new task (as well as replay examples). Each experiment was run independently three times; figures plot the mean performance across runs, with error bars showing the standard deviation. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            657
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B PROBE TASK WITH $100 \\%$ REPLAY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            485,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our goal in this experiment was to investigate more thoroughly than Figure 3 to what extent the mixture of on- and off-policy learning is necessary, instead of pure off-policy learning, in learning new tasks swiftly. We rerun our “probe task” experiments (Section 4.5), where the DMLab task natlab varying map randomized is presented at different positions in a cyclically repeating sequence of other DMLab tasks. In this case, however, we use CLEAR with $100 \\%$ (off-policy) replay experience. We observe that, unlike in the original experiment (Figure 5), the performance obtained on the probe task natlab varying map randomized deteriorates markedly as it appears later in the sequence of tasks. For later positions in the sequence, the probe task comprises a smaller percentage of replay experience, thereby impeding purely off-policy learning. This result underlines why CLEAR uses new experience, as well as replay, to allow rapid learning of new tasks. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/82f14b109e25ca17227e98ed4906725dc46304c60d185fbc72358fb992cabd45.jpg",
+        "image_caption": [
+            "Figure 7: This figure shows the same “probe task” setup as Figure 5, but with CLEAR using $100 \\%$ replay experience. Performance on the probe task natlab varying map randomized decreases markedly as it appears later in the sequence of tasks, emphasizing the importance of using a blend of new experience and replay instead of $100 \\%$ replay. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            295,
+            823,
+            786
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C FIGURES REPLOTTED ACCORDING TO CUMULATIVE SUM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            678,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we replot the results of our main experiments, so that the $y$ -axis shows the mean cumulative reward obtained on each task during training; that is, the reward shown for time $t$ is the average $( 1 / t ) \\sum _ { s < t } r _ { s }$ . This makes it easier to compare performance between models, though it smoothes out the individual periods of catastrophic forgetting. We also include tables comparing the values of the final cumulative rewards at the end of training. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/e7f2543c11be2cb79409127a54f0810fdb00e56045975e0d65208ffef8440009.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>explore...</td><td rowspan=1 colspan=1>rooms_collect...</td><td rowspan=1 colspan=1>rooms_keys...</td></tr><tr><td rowspan=1 colspan=1>Separate</td><td rowspan=1 colspan=1>29.24</td><td rowspan=1 colspan=1>8.79</td><td rowspan=1 colspan=1>19.91</td></tr><tr><td rowspan=1 colspan=1>Simultaneous</td><td rowspan=1 colspan=1>32.35</td><td rowspan=1 colspan=1>8.81</td><td rowspan=1 colspan=1>20.56</td></tr><tr><td rowspan=1 colspan=1>Sequential (no CLEAR)</td><td rowspan=1 colspan=1>17.99</td><td rowspan=1 colspan=1>5.01</td><td rowspan=1 colspan=1>10.87</td></tr><tr><td rowspan=1 colspan=1>CLEAR (50-50 new-replay)</td><td rowspan=1 colspan=1>31.40</td><td rowspan=1 colspan=1>8.00</td><td rowspan=1 colspan=1>18.13</td></tr><tr><td rowspan=1 colspan=1>CLEAR w/o behavioral cloning</td><td rowspan=1 colspan=1>28.66</td><td rowspan=1 colspan=1>7.79</td><td rowspan=1 colspan=1>16.63</td></tr><tr><td rowspan=1 colspan=1>CLEAR, 75-25 new-replay</td><td rowspan=1 colspan=1>30.28</td><td rowspan=1 colspan=1>7.83</td><td rowspan=1 colspan=1>17.86</td></tr><tr><td rowspan=1 colspan=1>CLEAR,100% replay</td><td rowspan=1 colspan=1>31.09</td><td rowspan=1 colspan=1>7.48</td><td rowspan=1 colspan=1>13.39</td></tr><tr><td rowspan=1 colspan=1>CLEAR,buffer5M</td><td rowspan=1 colspan=1>30.33</td><td rowspan=1 colspan=1>8.00</td><td rowspan=1 colspan=1>18.07</td></tr><tr><td rowspan=1 colspan=1>CLEAR,buffer 50M</td><td rowspan=1 colspan=1>30.82</td><td rowspan=1 colspan=1>7.99</td><td rowspan=1 colspan=1>18.21</td></tr></table>",
+        "bbox": [
+            184,
+            217,
+            812,
+            364
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/daf0d1b74b06e2d16d0138065bacc4f9791038986d3ee878f871910f54e23e89.jpg",
+        "image_caption": [
+            "Figure 8: Quantitative comparison of the final cumulative performance between standard training (“Sequential (no CLEAR)”) and various versions of CLEAR (see Figures 9, 10, 11, and 12 below) on a cyclically repeating sequence of DMLab tasks. We also include the results of training on each individual task with a separate network (“Separate”) and on all tasks simultaneously (“Simultaneous”) instead of sequentially. As described in Section 4.1, these situations represent no-forgetting scenarios and thus present upper bounds on the performance expected in a continual learning setting, where tasks are presented sequentially. Remarkably, CLEAR achieves performance comparable to “Separate” and “Simultaneous”, demonstrating that forgetting is virtually eliminated. ",
+            "Figure 9: Alternative plot of the experiments shown in Figure 1, showing the difference in cumulative performance between training on tasks separately, simultaneously, and sequentially (without using CLEAR). The marked decrease in performance for sequential training is due to catastrophic forgetting. As in our earlier plots, thicker line segments are used to denote times at which the network is gaining new experience on a given task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            506,
+            823,
+            628
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/55261fe95d499a1663f48d11348a53227eaf6ce98736d360b1b76681ea545d05.jpg",
+        "image_caption": [
+            "Figure 10: Alternative plot of the experiments shown in Figure 2, showing how applying CLEAR when training on sequentially presented tasks gives almost the same results as training on all tasks simultaneously (compare to sequential and simultaneous training in Figure 9 above). Applying CLEAR without behavioral cloning also yields decent results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            136,
+            794,
+            300
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/11d8ea8904016133e59f70f61c531a020561649bb8bbff91bee61ea8e356d851.jpg",
+        "image_caption": [
+            "Figure 11: Alternative plot of the experiments shown in Figure 3, comparing performance between using CLEAR with 75-25 new-replay experience, 50-50 new-replay experience, and $100 \\%$ replay experience. An equal balance of new and replay experience seems to represent a good tradeoff between stability and plasticity, while $100 \\%$ replay reduces forgetting but lowers performance overall. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            449,
+            823,
+            573
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/66269e241cd72c0f9e2fb3fbc361e24ce26e1033433b84119dd340560205801a.jpg",
+        "image_caption": [
+            "Figure 12: Alternative plot of the experiments shown in Figure 4, showing that reduced-size buffers still allow CLEAR to achieve essentially the same performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            720,
+            825,
+            843
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f68a41a5720d88fbd9d80ab353a3714f48d3a931ab2fa9338db10c4db18d7f6.jpg",
+        "table_caption": [
+            "Figure 13: Quantitative comparison of the final cumulative performance between baseline (standard training), CLEAR, Elastic Weight Consolidation (EWC), and Progress & Compress (P&C) (see Figure 14 below). Overall, CLEAR performs comparably to or better than P&C, and significantly better than EWC and baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>space_invaders</td><td rowspan=1 colspan=1>krull</td><td rowspan=1 colspan=1>beam_rider</td><td rowspan=1 colspan=1>hero</td><td rowspan=1 colspan=1>star-gunner</td><td rowspan=1 colspan=1>ms-pacman</td></tr><tr><td rowspan=1 colspan=1>Baseline</td><td rowspan=1 colspan=1>346.47</td><td rowspan=1 colspan=1>5512.36</td><td rowspan=1 colspan=1>952.72</td><td rowspan=1 colspan=1>2737.32</td><td rowspan=1 colspan=1>1065.20</td><td rowspan=1 colspan=1>753.83</td></tr><tr><td rowspan=1 colspan=1>CLEAR</td><td rowspan=1 colspan=1>426.72</td><td rowspan=1 colspan=1>8845.12</td><td rowspan=1 colspan=1>585.05</td><td rowspan=1 colspan=1>8106.22</td><td rowspan=1 colspan=1>991.74</td><td rowspan=1 colspan=1>1222.82</td></tr><tr><td rowspan=1 colspan=1>EWC</td><td rowspan=1 colspan=1>549.22</td><td rowspan=1 colspan=1>5352.92</td><td rowspan=1 colspan=1>432.78</td><td rowspan=1 colspan=1>4499.35</td><td rowspan=1 colspan=1>704.20</td><td rowspan=1 colspan=1>639.75</td></tr><tr><td rowspan=1 colspan=1>P&amp;C</td><td rowspan=1 colspan=1>455.34</td><td rowspan=1 colspan=1>7025.40</td><td rowspan=1 colspan=1>743.38</td><td rowspan=1 colspan=1>3433.10</td><td rowspan=1 colspan=1>1261.86</td><td rowspan=1 colspan=1>924.52</td></tr></table>",
+        "bbox": [
+            171,
+            101,
+            848,
+            174
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/e69e52e550d426a64e883ac2eee1eabc869e4fe44e4b41fe0eb0b5704c777283.jpg",
+        "image_caption": [
+            "Figure 14: Alternative plot of the experiments shown in Figure 6, showing that CLEAR attains comparable or better performance than the more complicated methods Progress & Compress (P&C) and Elastic Weight Consolidation (EWC), which also require information about task boundaries, unlike CLEAR. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            277,
+            261,
+            720,
+            622
+        ],
+        "page_idx": 14
+    }
+]

parse/train/S1gBz2C9tX/S1gBz2C9tX.md

@@ -0,0 +1,410 @@
+# IMPORTANCE RESAMPLING FOR OFF-POLICY POLICY EVALUATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Importance sampling is a common approach to off-policy learning in reinforcement learning. While it is consistent and unbiased, it can result in high variance updates to the parameters for the value function. Weighted importance sampling (WIS) has been explored to reduce variance for off-policy policy evaluation, but only for linear value function approximation. In this work, we explore a resampling strategy to reduce variance, rather than a reweighting strategy. We propose Importance Resampling (IR) for off-policy learning, that resamples experience from the replay buffer and applies a standard on-policy update. The approach avoids using importance sampling ratios directly in the update, instead correcting the distribution over transitions before the update. We characterize the bias and consistency of the our estimator, particularly compared to WIS. We then demonstrate in several toy domains that IR has improved sample efficiency and parameter sensitivity, as compared to several baseline WIS estimators and to IS. We conclude with a demonstration showing IR improves over IS for learning a value function from images in a racing car simulator.
+
+# 1 INTRODUCTION
+
+An important component of many learning systems is learning value functions for many policies. Some examples of such systems are the Horde architecture composed of General Value Functions (GVFs) (Sutton et al., 2011; Modayil et al., 2014), systems that use options (Sutton et al., 1999; Schaul et al., 2015a), predictive representation approaches (Sutton et al., 2005; Schaul and Ring, 2013; Silver et al., 2017) and systems with auxiliary tasks (Jaderberg et al., 2017). For each target policy, the value function returns the expected return from a state, and can provide useful information about (long-term) outcomes under different behaviors. Off-policy learning is critical for learning many value functions with different policies at scale, because it enables data to be generated from one behavior policy to update the values for each target policy in parallel.
+
+The typical strategy for off-policy learning is to use importance sampling (IS). For a given state $s$ , with action $a$ selected according to behaviour $\mu$ , the importance sampling ratio is the ratio between the probability of the action under the target policy $\pi$ and the behaviour: $\frac { \pi ( a | s ) } { \mu ( a | s ) }$ . The update is multiplied by this ratio, adjusting the action probabilities so that the expectation of the update is as if the actions were sampled according to the target policy $\pi$ . Though the IS estimator is unbiased and consistent (Kahn and Marshall, 1953; Rubinstein and Kroese, 2016), it can suffer from high or even infinite variance due to large magnitude IS ratios, in theory (Andradottir et al., 1995) and in practice (Precup et al., 2001; Mahmood et al., 2014; 2017).
+
+There have been some attempts to modify policy evaluation algorithms to mitigate this variance.1 Weighted IS (WIS) algorithms have been introduced (Precup et al., 2001; Mahmood et al., 2014; Mahmood and Sutton, 2015), which normalize each update by the sample average of the ratios. These algorithms did improve learning over standard IS strategies, but are not straightforward to extend to nonlinear function approximation. In the offline setting, a reweighting scheme, called importance sampling with unequal support (Thomas and Brunskill, 2017), was introduced to account for samples where the ratio is zero, in some cases significantly reducing variance. Another strategy has been to use rescaling or truncation of IS ratios, such as in V-trace (Espeholt et al., 2018). Several other methods have introduced bias similarly for algorithms with eligibility traces by truncating or scaling IS ratios to maintain stability of the eligibility trace vector, including Tree-Backup (Precup et al., 2000), Retrace (Munos et al., 2016) and ABQ (Mahmood et al., 2017). Truncation of IS-ratios in V-trace can incur significant bias, and this additional truncation parameter does need to be tuned.
+
+An alternative to reweighting updates is to instead correct the distribution before updating the estimator using weighted bootstrap sampling: resampling a new set of data from the previously generated samples (Smith et al., 1992; Arulampalam et al., 2002). Consider a setting where a buffer of data is stored, generated by a behavior policy. Samples for policy $\pi$ can be obtained by resampling from this buffer, proportionally to $\frac { \pi ( a | s ) } { \mu ( a | s ) }$ for state-action pairs $( s , a )$ in the buffer. In the sampling literature, this strategy has been proposed under the name Sampling Importance Resampling (SIR) (Rubin, 1988; Smith et al., 1992; Gordon et al., 1993), and has been particularly successful for Sequential Monte Carlo sampling (Gordon et al., 1993; Skare et al., 2003). Such resampling strategies have also been popular in classification, with over-sampling or under-sampling typically being preferred to weighted (cost-sensitive) updates (Lopez et al., 2013).
+
+Such a resampling strategy, however, has yet to be proposed for policy evaluation, though there are several potential benefits. By correcting the distribution before updating, standard on-policy updates can be used, without needing to modify or re-derive with IS ratios. This simplifies application of different optimizers, such as those with momentum terms. Another benefit is that the magnitude of the updates will vary less—because updates are not multiplied by very small or very large importance sampling ratios—potentially reducing variance of stochastic updates and simplifying stepsize selection. Resampling should have larger benefits for learning approaches, as compared to averaging or numerical integration problems, because updates accumulate in the weight vector and change the optimization trajectory of the weights. For example, very large importance sampling ratios could destabilize the weights. Such a problem does not occur for resampling, as instead the same transition will simply be resampled multiple times, spreading out the large magnitude update across multiple updates. On the other extreme, with small ratios, IS will waste updates on transitions with very small IS ratios. Resampling, therefore, should have better sample efficiency. Two important questions, therefore, are if these hypothesized advantages manifest in practice in off-policy learning, and how SIR can be extended for use in policy evaluation.
+
+In this work, we investigate the use of SIR for online off-policy policy evaluation. We first introduce Importance Resampling (IR), which uses an SIR strategy to sample transitions from a buffer of (recent) transitions. These sampled transitions are then used for on-policy updates. We show that IR, with a sliding-window buffer, is a consistent estimator of the one-step on-policy updates, with the same bias as WIS. We then empirically investigate IR on three toy domains and a racing car simulation learning from images. We find that IR is more sample efficient—learning more quickly in terms of number of updates—and has reduced sensitivity in terms of learning rate parameters, for both fixed parameters and within the RMSProp optimizer.
+
+# 2 BACKGROUND
+
+We consider the problem of learning General Value Functions (GVFs) (Sutton et al., 2011). The agent interacts in an environment defined by a set of states $s$ , a set of actions $\mathcal { A }$ and Markov transition dynamics, with probability $\mathrm { P } ( s ^ { \prime } | s , a )$ of transitions to state $s ^ { \prime }$ when taking action $a$ in state $s$ . A GVF is defined for policy $\pi : S \times A \to [ 0 , 1 ]$ , cumulant $c : S \times \mathcal { A } \times \mathcal { S }  \mathbb { R }$ and continuation function $\gamma : S \times \mathcal { A } \times \mathcal { S }  [ 0 , 1 ]$ $c _ { t + 1 } \{ \stackrel { \mathrm { d e f } } { = } c ( S _ { t } , A _ { t } , S _ { t + 1 } )$ $\gamma _ { t + 1 } \{ \stackrel { \mathrm { d e f } } { = } \gamma ( S _ { t } , A _ { t } , S _ { t + 1 } )$ $V ( s ) \stackrel { \mathrm { d e f } } { = } \mathbb { E } _ { \pi } \left[ c _ { t + 1 } + \gamma _ { t + 1 } c _ { t + 2 } + \gamma _ { t + 1 } \gamma _ { t + 2 } c _ { t + 3 } + \ldots | S _ { t } = s \right] = \mathbb { E } _ { \pi } \left[ \sum _ { i = 1 } ^ { \infty } \left( \prod _ { j = 0 } ^ { i - 1 } \gamma _ { t + j } \right) c _ { t + i } | S _ { t } = s \right] .$
+
+The operator $\mathbb { E } _ { \pi }$ indicates the actions are selected according to policy $\pi$ for the expectation. GVFs encompass standard definitions of value functions, where the cumulant is a reward and the continuation function is a constant. Otherwise, they specify a broader set of value functions, that enable predictions about discounted sums of others signals into the future, when following a target policy $\pi$ . These values are typically estimated using parametric function approximation, with parameters $\theta \in \mathbb { R } ^ { d }$ defining approximate values $V _ { \theta } ( s )$ .
+
+In off-policy learning, transitions are sampled according to behaviour policy, rather than the target policy. To get an unbiased sample of an update to the parameters, the action probabilities need to be adjusted. Consider on-policy temporal difference (TD) learning, with update $\alpha _ { t } \delta _ { t } \nabla _ { \theta } V _ { \theta } ( s )$ for a given $S _ { t } = s$ , for stepsize $\alpha _ { t } \in \mathbb { R } ^ { + }$ and TD-error $\delta _ { t } \stackrel { \mathrm { d e f } } { = } C _ { t + 1 } + \gamma _ { t + 1 } V _ { \theta } ( S _ { t + 1 } ) - V _ { \theta } ( s )$ . If actions are instead sampled according to a behaviour policy $\mu : \mathcal { S } \times \mathcal { A }  [ 0 , 1 ]$ , then we can use importance sampling (IS) to modify the update, giving the off-policy TD update $\alpha _ { t } \rho _ { t } \delta _ { t } \nabla _ { \theta } V _ { \theta } ( s )$ for IS ratio $\rho _ { t } \stackrel { \mathrm { d e f } } { = } \frac { \pi ( A _ { t } | S _ { t } ) } { \mu ( A _ { t } | S _ { t } ) }$ . Given state $S _ { t } = s$ , if $\mu ( a | s ) > 0$ when $\pi ( a | s ) > 0$ , then the expected value of these two updates are equal. To see why, notice that
+
+$$
+\mathbb { E } _ { \mu } \left[ \alpha _ { t } \rho _ { t } \delta _ { t } \nabla _ { \theta } V _ { \theta } ( s ) | S _ { t } = s \right] = \alpha _ { t } \nabla _ { \theta } V _ { \theta } ( s ) \mathbb { E } _ { \mu } \left[ \rho _ { t } \delta _ { t } | S _ { t } = s \right]
+$$
+
+and we have
+
+$$
+\begin{array} { r l } { \overline { { \Omega _ { \mu } } } \left[ \rho _ { t } \delta _ { t } | S _ { t } = s \right] = \displaystyle \sum _ { a \in A } \mu ( a | s ) \mathbb { E } \left[ \rho _ { t } \delta _ { t } | S _ { t } = s , A _ { t } = a \right] } & { = \displaystyle \sum _ { a \in A } \mu ( a | s ) \frac { \pi ( a | s ) } { \mu ( a | s ) } \mathbb { E } \left[ \delta _ { t } | S _ { t } = s , A _ { t } = a \right] } \\ { = \displaystyle \sum _ { a \in A } \pi ( a | s ) \mathbb { E } \left[ \delta _ { t } | S _ { t } = s , A _ { t } = a \right] } & { \quad = \mathbb { E } _ { \pi } \left[ \delta _ { t } | S _ { t } = s \right] . } \end{array}
+$$
+
+Other on-policy updates can also be modified with IS ratios to adjust these action probabilities.
+
+Though unbiased, IS can be high-variance, and so weighted IS ratios are typically preferred. For a batch consisting of transitions $\{ ( s _ { i } , a _ { i } , s _ { i + 1 } , c _ { i + 1 } , \rho _ { i } ) \} _ { i = 1 } ^ { n }$ , batch WIS uses a normalized estimate for the update. For example, an offline batch WIS TD algorithm would use update $\begin{array} { r } { \alpha _ { t } \frac { \rho _ { t } \delta _ { t } \nabla _ { \theta } V _ { \theta } ( s ) } { \sum _ { i = 1 } ^ { n } \rho _ { i } } } \end{array}$ . When learning online, an efficient WIS update is less straightforward, and has resulted in algorithms specialized to the tabular setting (Precup et al., 2001) or linear functions (Mahmood et al., 2014; Mahmood and Sutton, 2015). We nonetheless use WIS as baseline, in the experiments and theory.
+
+# 3 RESAMPLING STRATEGIES FOR OFF-POLICY POLICY EVALUATION
+
+In this section, we introduce resampling, as an alternative to importance sampling for off-policy learning. We first introduce the algorithm, Importance Resampling (IR). We then prove consistency and characterize the bias. We conclude with a discussion about its variance properties.
+
+Importance Resampling requires access to a buffer of samples, from which we can resample. Replaying experience from a buffer was introduced as a biologically plausible mechanism to reuse old experience (Lin, 1992; 1993), and has since become common for improving sample efficiency, particularly for control (Mnih et al., 2015; Schaul et al., 2015b). In the simplest case—which we assume here—the buffer is a sliding window of the most recent $n$ samples, $\{ ( s _ { i } , a _ { i } , s _ { i + 1 } , c _ { i + 1 } , \rho _ { i } ) \} _ { i = t - n } ^ { t }$ , at time step $t > n$ . These samples are generated by taking actions according to behaviour $\mu$ , and so the tuples are generated with probability $d _ { \mu } ( s ) \mu ( a \vert s ) \mathrm { P } ( s ^ { \prime } \vert s , a )$ , where $d _ { \mu } : S  [ 0 , 1 ]$ is the stationary distribution for policy $\mu$ . The goal is to obtain samples instead according to $\bar { d _ { \mu } } ( s ) \bar { \pi } ( a | s ) \mathrm { P } ( s ^ { \prime } | s , a )$ , as if we had taken actions according to policy $\pi$ from state $s \sim d _ { \mu }$ . This assumption—that states are still sampled from $d _ { \mu }$ —underlies most off-policy learning algorithms; very few attempt to use IS to adjust probabilities $d _ { \mu }$ to $d _ { \pi }$ (Precup et al., 2001).
+
+The IR algorithm is simple: resample a mini-batch of size $k$ on each step $t$ from the buffer of size $n$ , proportionally to $\rho _ { i }$ in the buffer. Standard on-policy updates, such as on-policy TD or on-policy gradient TD, are then used on this resample. The key difference to IS and WIS is that the sampling distribution itself is corrected (see Theorem C.1), before the update, whereas IS and WIS correct the update itself. This small difference, however, can have larger ramifications practically, particularly with updates that accumulate in the parameters.
+
+We consider two variants of IR: with and without bias correction. For point $t _ { j }$ sampled from the buffer, let $\Delta _ { t _ { j } }$ be the on-policy update for that transition. For example, for TD, $\tilde { \Delta t _ { t _ { j } } } = \delta _ { t _ { j } } \nabla _ { \theta } V _ { \theta } \big ( s _ { t _ { j } } \big )$ . The first step for either variant is to sample a mini-batch of size $k$ from the buffer, proportionally to $\rho _ { i }$ , as described above. The standard IR update simply uses a mini-batch, whereas Bias-Corrected IR (BC-IR) pre-multiplies with the average ratio in the buffer $\textstyle { \bar { \rho } } _ { t } = { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } \rho _ { i }$ ,
+
+$$
+\begin{array} { r } { { \mathbf { I R } : \qquad \alpha _ { t } \frac { 1 } { k } \displaystyle \sum _ { j = 1 } ^ { k } \Delta _ { t _ { j } } } } \end{array}
+$$
+
+$$
+\begin{array} { r } { { \mathbf { B C - I R : } } \qquad \alpha _ { t } \bar { \rho } _ { t } \frac { 1 } { k } \displaystyle \sum _ { j = 1 } ^ { k } \Delta _ { t _ { j } } . } \end{array}
+$$
+
+BC-IR negates bias introduced by the average ratio in the buffer deviating significantly from the true mean. For reasonably large buffers, $\bar { \rho } _ { t }$ will be close to 1 making IR and BC-IR have nearidentical updates. In practice, we find the two variants of IR perform similarly. Nonetheless, they do have different theoretical properties, particularly for small buffer sizes $n$ , so we characterize both. Though BC-IR has better bias properties, IR is simpler—not requiring any modification to the updates—which may be more important than the small amount of bias introduced by the IR without bias correction. For this reason, we advocate for and analyze both variants.
+
+Across all results, we make the following assumption.
+
+Assumption 1. Transition tuples $X _ { i } = ( S _ { i } , A _ { i } , S _ { i + 1 } )$ are sampled i.i.d. according to the distribution $p ( \bar { x } = ( s , a , s ^ { \prime } ) ) = d _ { \mu } ( s ) \mu ( a | s ) \mathrm { P } ( s ^ { \prime } | s , a )$ , for $i = 1 , 2 , 3 , \dots$ .
+
+To distinguish expectations under $p ( x ) = d _ { \mu } ( s ) \mu ( a | s ) \mathrm { P } ( s ^ { \prime } | s , a )$ and $q ( x ) = d _ { \mu } ( s ) \pi ( a | s ) \mathrm { P } ( s ^ { \prime } | s , a )$ , we overload the notation from above, using operators $\mathbb { E } _ { \mu }$ and $\mathbb { E } _ { \pi }$ respectively. To reduce clutter, we will typically write $\mathbb { E }$ to mean $\mathbb { E } _ { \mu }$ , because most expectations are under the sampling distribution.
+
+# 3.1 BIAS OF IR
+
+We first show that IR is biased, and that its bias is actually equal to batch WIS (in Theorem 3.1). This bias is small for reasonably large $n$ , because it is proportional to $1 / n$ . In terms of mean-squared error, composed of squared bias and variance, this term is $\mathbf { \bar { 1 } } / n ^ { 2 }$ and is relatively negligible compared to the variance. Nonetheless, for smaller buffers, such bias could have an impact. We show that with a simple modification, in BC-IR, we obtain an unbiased estimate of the update (Corollary 3.1.1).
+
+Theorem 3.1. [Bias for a fixed buffer of size n] Assume a buffer $B$ of n transitions is sampled i.i.d., according to $d _ { \mu } ( s ) \mu ( a | s ) \mathrm { P } ( s ^ { \prime } | s , a )$ . Let $\begin{array} { r } { X _ { \mathrm { I R } } \ \stackrel { \mathrm { d e f } } { = } \ \frac { 1 } { k } \sum _ { j = 1 } ^ { k } \Delta _ { i _ { j } } } \end{array}$ for transitions $i _ { 1 } , \dots , i _ { k }$ sampled randomly from the buffer proportionally to $\rho _ { i }$ . Let $\begin{array} { r } { X _ { \mathrm { { W I S } * } } \stackrel { \mathrm { d e f } } { = } \sum _ { i = 1 } ^ { n } \frac { \rho _ { i } } { \sum _ { j = 1 } ^ { n } \rho _ { j } } \Delta _ { i } } \end{array}$ ef  Pni=1 P ρinj=1 ρj be the batch WIS estimator of the update, with $\rho _ { i } \stackrel { \mathrm { d e f } } { = } \pi ( A _ { i } | S _ { i } ) / \mu ( A _ { i } | S _ { i } )$ . Then, $\mathbb { E } [ X _ { \mathrm { I R } } ] = \mathbb { E } [ X _ { \mathrm { W I S * } } ]$ , and so the bias of $X _ { \mathrm { I R } }$ is proportional to
+
+$$
+\widetilde { \mathrm { B i a s } } ( X _ { \mathrm { I R } } ) = \mathbb { E } [ X _ { \mathrm { I R } } ] - \mathbb { E } _ { \boldsymbol \pi } [ \Delta ] \propto \frac { 1 } { n } ( \mathbb { E } _ { \boldsymbol \pi } [ \Delta ] \sigma _ { \rho } ^ { 2 } - \sigma _ { \rho , \Delta } \sigma _ { \rho } \sigma _ { \Delta } )
+$$
+
+where get po $\mathbb { E } _ { \pi } [ \Delta ]$ i ro; ons from ; and co $S$ taken riance $\pi$ $\begin{array} { r } { \sigma _ { \rho } ^ { 2 } \ = \ \mathrm { \tilde { V } a r } ( \frac { 1 } { n } \grave { \sum } _ { j = 1 } ^ { n } \rho _ { j } ) } \end{array}$ $\begin{array} { r } { \sigma _ { \Delta } ^ { 2 } \ = \ \mathrm { V a r } ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \rho _ { i } \Delta _ { i } ) } \end{array}$ $\sigma _ { ( \rho , \Delta ) } =$ $\begin{array} { r } { \mathrm { C o v } \big ( \frac { 1 } { n } \sum _ { j = 1 } ^ { n } \rho _ { j } , \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \rho _ { i } \Delta _ { i } \big ) } \end{array}$ .
+
+Proof. Notice first that when we weight with $\rho _ { i }$ , this is equivalent to weighting with $\frac { d _ { \mu } ( \tilde { S _ { i } } ) \pi ( A _ { i } | S _ { i } ) \mathrm { P } ( S _ { i + 1 } | S _ { i } , A _ { i } ) } { d _ { \prime \prime } ( S _ { i } ) \mu ( A _ { i } | S _ { i } ) \mathrm { P } ( S _ { i + 1 } | S _ { i } , A _ { i } ) }$ and so we are applying the correct IS ratio for the transition.
+
+$$
+\begin{array} { r l } {  { \mathbb { E } [ X _ { \mathrm { I R } } ] = \mathbb { E } [ \mathbb { E } \bigl [ X _ { \mathrm { I R } } \vert B \bigr ] ] = \mathbb { E } [ \mathbb { E } [ \frac { 1 } { k } \sum _ { j = 1 } ^ { k } \Delta _ { i j } \vert B ] ] = \mathbb { E } [ \frac { 1 } { k } \sum _ { j = 1 } ^ { k } \mathbb { E } \bigl [ \Delta _ { i j } \vert B \bigr ] ] } \quad } & { { } } \\ { \displaystyle } & { { } = \mathbb { E } \bigg [ \sum _ { i = 1 } ^ { n } \frac { \rho _ { i } } { \sum _ { j = 1 } ^ { n } \rho _ { j } } \Delta _ { i } \bigg ] = \mathbb { E } \bigl [ X _ { \mathrm { W I S * } } \big ] \quad \quad \triangleright \ \mathrm { b e c a u s e } \ \mathbb { E } \bigl [ \Delta _ { i _ { j } } \vert B \bigr ] = \sum _ { i = 1 } ^ { n } \frac { \rho _ { i } } { \sum _ { j = 1 } ^ { n } \rho _ { j } } \Delta _ { i } } \end{array}
+$$
+
+This bias of $X _ { \mathrm { I R } }$ is therefore the same as batch WIS, which is characterized in (Owen, 2013, Section 2.7), completing the proof. □
+
+This bias of IR will be small for reasonably large $n$ , both because it is proportional to $1 / n$ and because larger $n$ will result in lower variance of the average ratios and average update for the buffer. In particular, as $n$ grows, these variances decay proportionally to $n$ .
+
+Corollary 3.1.1. Bias-corrected $I R$ , with estimator $\begin{array} { r } { X _ { \mathrm { B C } } \ { \stackrel { \mathrm { d e f } } { = } } \ { \frac { \bar { \rho } } { k } } \sum _ { j = 1 } ^ { k } \Delta _ { i _ { j } } } \end{array}$ for $\begin{array} { r } { \bar { \rho } = \frac { 1 } { n } \sum _ { j = 1 } ^ { n } \rho _ { j } } \end{array}$ unbiased: $\mathbb { E } [ X _ { \mathrm { B C } } ] = \mathbb { E } _ { \pi } [ \Delta ]$ .
+
+Proof.
+
+$$
+\begin{array} { r l } & { \Xi [ X _ { \mathrm { B C } } ] = \mathbb { E } \Big [ \frac { \bar { \rho } } { k } \sum _ { j = 1 } ^ { k } \mathbb { E } [ \Delta _ { i _ { j } } | B ] \Big ] = \mathbb { E } \Big [ \bar { \rho } \displaystyle \sum _ { i = 1 } ^ { n } \frac { \rho _ { i } } { \sum _ { j = 1 } ^ { n } \rho _ { j } } \Delta _ { i } \Big ] = \mathbb { E } \Big [ \frac { 1 } { n } \displaystyle \sum _ { i = 1 } ^ { n } \rho _ { i } \Delta _ { i } \Big ] = \frac { 1 } { n } \displaystyle \sum _ { i = 1 } ^ { n } \mathbb { E } \Big [ \frac { \pi ( A _ { i } | S _ { i } ) } { \mu ( A _ { i } | S _ { i } ) } \Delta _ { i } \Big ] } \\ & { \phantom { \Xi _ { \rho } } = \frac { 1 } { n } \displaystyle \sum _ { i = 1 } ^ { n } \mathbb { E } \Big [ \frac { d _ { \mu } ( S _ { i } ) \pi ( A _ { i } | S _ { i } ) \mathrm { P } ( S _ { i + 1 } | S _ { i } , A _ { i } ) } { d _ { \mu } ( S _ { i } ) \mu ( A _ { i } | S _ { i } ) \mathrm { P } ( S _ { i + 1 } | S _ { i } , A _ { i } ) } \Delta _ { i } \Big ] = \frac { 1 } { n } \displaystyle \sum _ { i = 1 } ^ { n } \mathbb { E } _ { \pi } \left[ \Delta \right] = \mathbb { E } _ { \pi } \left[ \Delta \right] . } \end{array}
+$$
+
+# 3.2 CONSISTENCY OF IR
+
+Consistency of IR in terms of an increasing buffer, with $n  \infty$ , is a relatively straightforward extension on results for SIR, with or without bias correction (see Theorem C.1 in Appendix C). More interesting is consistency in terms of increasing interactions with the environment, $t \to \infty$ , with a fixed length buffer, as will be the case in practice. IR, without bias correction, is asymptotically biased in this case; in fact, its asymptotic bias is the one characterized above for a fixed length buffer in Theorem 3.1. This asymptotic bias, though, is proportional to $1 / n$ , which is negligible for typical buffer sizes. BC-IR, on the other hand, is consistent, even with a sliding window, as we show in the following theorem.
+
+Theorem 3.2. Let $B _ { i } = \{ X _ { i - n + 1 } , . . . , X _ { i } \}$ be the buffer of the most recent n transitions sampled by time i, i.i.d. as ssamples from buffer ified in Assumption. Define the sliding $^ { l }$ . Let windo $X _ { \mathrm { B C } } ^ { ( i ) }$ be theimator stimator, with . Assume the $k$ $B _ { i }$ $\begin{array} { r } { X _ { t } \ \stackrel { \mathrm { d e f } } { = } \ \frac { 1 } { t } \sum _ { i = 1 } ^ { t } X _ { \mathrm { B C } } ^ { ( i ) } } \end{array}$ exists a $c > 0$ such that $\mathrm { V a r } ( X _ { \mathrm { B C } } ^ { ( i ) } ) \leq c$ ∀i. Then, as $t \to \infty$ , $X _ { t }$ converges in probability to $\mathbb { E } _ { \pi } [ \Delta ]$ .
+
+Proof. Notice first that $X _ { \mathrm { B C } } ^ { ( i ) }$ is random because $B _ { i }$ is random and because transitions are sampled from $B _ { i }$ . Therefore, given $B _ { i }$ , $X _ { \mathrm { B C } } ^ { ( i ) }$ is independent of other random variables $B _ { j }$ and $X _ { \mathrm { B C } } ^ { ( j ) }$ for $j \neq i$ . Now, using Corollary 3.1.1, we can show that BC-IR is unbiased for a sliding window
+
+$$
+\mathbb { E } \big [ X _ { t } \big ] = \mathbb { E } \Big [ \frac { 1 } { t } \sum _ { i = 1 } ^ { t } X _ { \mathrm { B C } } ^ { ( i ) } \Big ] = \frac { 1 } { t } \sum _ { i = 1 } ^ { t } \mathbb { E } \big [ \mathbb { E } [ X _ { \mathrm { B C } } ^ { ( i ) } | B _ { i } ] \big ] = \mathbb { E } _ { \pi } \left[ \Delta \right] .
+$$
+
+Next, we show that $\begin{array} { r } { \operatorname* { l i m } _ { | i - j | \to \infty } \mathrm { C o v } ( X _ { \mathrm { B C } } ^ { ( i ) } , X _ { \mathrm { B C } } ^ { ( j ) } ) = 0 } \end{array}$ . For $| i - j | \geq m ,$ , $B _ { i }$ and $B _ { j }$ are independent, because they are disjoint sets of i.i.d. random variables. Correspondingly, $X _ { \mathrm { B C } } ^ { ( i ) }$ is in$X _ { \mathrm { B C } } ^ { ( j ) }$ ce, we get that . The first term $\mathrm { C o v } ( X _ { \mathrm { B C } } ^ { ( i ) } , \bar { X _ { \mathrm { B C } } ^ { ( j ) } } ) =$ $\mathrm { C o v } ( X _ { \mathrm { B C } } ^ { ( i ) } , X _ { \mathrm { B C } } ^ { ( j ) } | B _ { i } , B _ { j } ) + \mathrm { C o v } ( \mathbb { E } [ X _ { \mathrm { B C } } ^ { ( i ) } | B _ { i } ] , \mathbb { E } [ X _ { \mathrm { B C } } ^ { ( j ) } | B _ { j } ] ) = 0$ $X _ { \mathrm { B C } } ^ { ( i ) }$ is independent of X(j)BC given $B _ { i }$ , and the second term is zero because $B _ { i }$ and $B _ { j }$ are independent. Therefore, $\begin{array} { r } { \operatorname* { l i m } _ { | i - j | \to \infty } \mathrm { C o v } ( X _ { \mathrm { B C } } ^ { ( i ) } , X _ { \mathrm { B C } } ^ { ( j ) } ) = 0 } \end{array}$ .
+
+Using the assumption on the variance, we can apply Lemma C.3 to $X _ { t }$ to get the desired result.
+
+# 3.3 VARIANCE AND EFFECTIVE SAMPLE SIZE
+
+In this section, we provide some intuition on the variance properties of the discussed off-policy estimators. Similarly to bias, we can characterize the variance of the IR estimator relative to batch WIS. $X _ { \mathrm { W I S * } }$ is able to use a batch update on all the data in the buffer, which should result in a lowvariance estimate but is an unrealistic algorithm to use in practice. Instead, it provides a benchmark, where the goal is to obtain similar variance to $X _ { \mathrm { W I S * } }$ , but within realistic computational restrictions. Because of the clear relationship between IR and WIS, as used in Theorem 3.1, we can easily characterize the variance of $X _ { \mathrm { I R } }$ relative to $X _ { \mathrm { W I S * } }$ using the law of total covariance:
+
+$$
+\begin{array} { r l r } & { } & { \mathbb { V } ( X _ { \mathrm { I R } } ) = \mathbb { V } \left[ \mathbb { E } [ X _ { \mathrm { I R } } | B ] \right] + \mathbb { E } \left[ \mathbb { V } [ X _ { \mathrm { I R } } | B ] \right] } \\ & { } & { = \mathbb { V } \left[ X _ { \mathrm { W I S * } } \right] + \mathbb { E } \left[ \mathbb { V } [ X _ { \mathrm { I R } } | B ] \right] ~ } \end{array}
+$$
+
+where the variability is due to having randomly sampled buffers $B$ and random sampling from $B$ . The second term corresponds to the noise introduced by sampling a mini-batch of $k$ transitions from the buffer $B$ , instead of using the entire buffer like WIS. For more insight, we can expand this second term, $\begin{array} { r } { \mathbb { E } \left[ \mathbb { V } [ X _ { \mathrm { I R } } | B ] \right] = \mathbb { E } \left[ ( \frac { 1 } { k } \sum _ { j = 1 } ^ { k } \Delta _ { i _ { j } } - \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \Delta _ { i } ) ^ { 2 } | B \right] } \end{array}$ , where we consider the variance independently for each element of $\Delta _ { i }$ and so apply the square element-wise. The variability is not due to IS ratios, and instead arises from variability in the updates themselves. Therefore, the variance of IR corresponds to the variance of WIS, with some additional variance due to this variability around the average update in the buffer.
+
+This variance contrasts the variance of the corresponding mini-batch IS estimator:
+
+$$
+\mathbb { V } \Big ( \frac { 1 } { k } \sum _ { j = 1 } ^ { k } \rho _ { i _ { j } } \Delta _ { i _ { j } } \Big ) = \mathbb { E } \Big [ \Big ( \frac { 1 } { k } \sum _ { j = 1 } ^ { k } \rho _ { i _ { j } } \Delta _ { i _ { j } } - \mathbb { E } _ { \pi } [ \Delta ] \Big ) ^ { 2 } \Big ]
+$$
+
+For large importance sampling ratios, this mini-batch can deviate significantly around the mean update. Further, this deviation around the mean update is across all transitions, unlike $\mathbb { E } \left[ \mathbb { V } [ X _ { \mathrm { I R } } | B ] \right]$ which reflects the expected deviation for a buffer of size $n$ . The IS estimator is unbiased, as opposed to IR and WIS which both introduce some bias. A more fair comparison is to BC-IR, which is unbiased, with variance
+
+$$
+\mathbb { V } \Big ( X _ { \mathrm { B C } } \Big ) = \mathbb { E } \Big [ \Big ( \frac { \bar { \rho } } { k } \sum _ { j = 1 } ^ { k } \Delta _ { i _ { j } } - \mathbb { E } _ { \pi } [ \Delta ] \Big ) ^ { 2 } \Big ]
+$$
+
+It is difficult to state generally that the variability of the IS estimator will be greater than $X _ { \mathrm { B C } }$ , because it depends on the properties of the update vector $\Delta _ { i _ { j } }$ itself. However, the key difference between them is that $X _ { \mathrm { B C } }$ multiplies all the updates by the averaged ratio, whereas IS includes individual (potentially high magnitude) ratios inside the sum.
+
+Finally, the variance of IR will be affected by what is known as the effective sample size. For data with several high magnitude ratios, and many small ratios, the IS estimator will likely suffer from high-variance updates. IR, however, will not be completely robust to this setting either: it will prevent high magnitude updates, but will be sampling from an effectively smaller dataset. This effective size is smaller because IR will repeatedly sample the same transitions, and potentially never sample some of the transitions with small IS ratios. With less data, we typically incur more variance.
+
+One common estimator of effective sample size is $\frac { \left( \sum _ { i = 1 } ^ { n } \rho _ { i } \right) ^ { 2 } } { \sum _ { i = 1 } ^ { n } \rho _ { i } ^ { 2 } }$ (Kong et al., 1994; Martino et al., 2017). This estimate lies between 1 and $n$ . When the effective sample size is low, this indicates that most of the probability is concentrated on a few samples, which could be problematic. An important next step is to better understand theoretically the implications of effective sample size. Here, we now turn to experiments to gain more insight into the relative efficacy of IR to IS, in settings including such skewed ratios.
+
+# 4 EXPERIMENTS
+
+In this section, we present results for predictions made with difficult polices in three domains. We compare IR and BC-IR 2 to an importance sampling approach using uniformly sampled experiences from the replay buffer $\mathrm { ( E R + I S ) }$ , and three variants of weighted importance sampling (WIS). The three variants of WIS considered are WIS-Batch, WIS-Buffer, and WIS-Optimal discussed further in the appendix3 4. For tabular domains, we don’t average over the mini-batch updates, although doing so won’t change results significantly. We report parameter studies and learning curves, excluding buffer size studies, on a single buffer size shared between all the methods. Although results from other buffer sizes (not shown here) have similar conclusions. We show $9 5 \%$ confidence intervals on all results unless otherwise specified.
+
+# 4.1 SETTINGS
+
+Random Walk Markov Chain We use a typically constructed random walk Markov chain (Sutton and Barto, 2018) with 8 non-terminating states and 2 terminating, with a reward of 1 on the transition to the right-most terminal state and 0 everywhere else. The agent follows a policy $\mu$ and learns the value function according to a target policy $\pi$ . We compute the root mean squared value error (RMSVE) on every training step with a value function found using dynamic programming with threshold 10−15.
+
+![](images/bcd65fdffeefcca784d605af84696eb3d58b1bd70492bd11751eeb241a98c7ab.jpg)
+
+![](images/c9d1e9dbb09a160e873f2634e41bcc9abdfeb5ea4f9ef18f134b1e29a751ab87.jpg)  
+Figure 1: Learning rate sensitivity study in the Random Walk Markov Chain with buffer size $n =$ 15000, batch size $b = 1 6$ For simplicity we write the policies as follows: $\mu = [ \mu ( \mathrm { l e f t } | \cdot )$ , $\mu ( \mathrm { r i g h t } | )$ . left $\mu = [ 0 . 5 , 0 . 5 ]$ , $\pi = [ 0 . 1 , 0 . 9 ]$ , center $\mu = [ 0 . 9 , 0 . 1 ]$ , $\pi = [ 0 . 1 , 0 . 9 ]$ , right $\mu = [ 0 . 9 9 , 0 . 0 1 ] , \pi =$ [0.01, 0.99]. Additional results using V-Trace and Sarsa can be found in the appendix B.1   
+Figure 2: left and center Buffer size study for the random walk markov chain and four rooms domain respectively. We select the best settings for each buffersize and report the average RMSVE right Four rooms domain learning rate sensitivities parameter study.
+
+Four Rooms Environment The four rooms domain is a well known hard domain used for training options (Stolle and Precup, 2002). The behavior policy followed by the agent is equiprobable everywhere except for 25 randomly selected states which take the action down with probability 0.05 with remaining probability split equally amongst the other actions. The 25 random states are the same for all runs, but we also evaluated different states for each run (see appendix). The target policy of interest is to take the down action deterministically, inducing highly variant IS ratios. The cumulant for the value function is 1 when the agent hits a wall and 0 otherwise. The continuation function is $\gamma = 0 . 9$ terminating when the agent hits a wall. We calculate the RMSVE similarly to the Markov Chain.
+
+Simulated Car Domain We use the TORCs race car simulator to perform scaling experiments using neural networks. We set up the simulator to produce $6 4 \mathrm { x } 1 2 8$ cropped grayscale images. We have an underlying deterministic steering controller that produces steering actions $a _ { d e t } \in [ - 1 , + 1 ]$ and take an action with probability defined by a Gaussian a $\mathcal { N } ( a _ { d e t } , 0 . 1 )$ . We show a demonstration learning a single GVF with cumulant 1 when the car is near the center of the road (signal provided by Torcs), continuation function with 0.9 everywhere with terminating condition the same as the cumulant, and a target policy modeled as a gaussian $\mathcal { N } ( 0 . 1 5 , 0 . 0 0 7 5 )$ , which corresponds to steering left.
+
+# 4.2 RESULTS
+
+In each of the domains tested we see significant improvements in the range of effective learning rates. The most stark example is seen in the right plot of figure 1. Here the behaviour policy induces importance sampling ratios as high as 99 while also having very few effective samples from which to train. After 1000 training epochs only a single learning rate seemed to not diverge using $\mathrm { E R + I S }$ and WIS-Buffer. In this same setting, IR performs very similar to the value function trained with on policy data. We also see lower sensitivity to learning rate in the four rooms environment, rightmost figure 2. 5
+
+Another benefit of IR is the gains in sample efficiency, and the focus on potentially rare samples following the target policy. We show this with the learning curves found in figure 3. In the random walk and four rooms domains we see WIS-Buffer and WIS-Batch perform approximately the same as $\mathrm { E R + I S }$ with IR outperforming the competitors. This can be attributed to IR’s resampling scheme, where we see more samples important to training. This is especially apparent in the four rooms experiments, where we may only get a few chances to train from certain hard to reach states. The uniform sampling methods will more likely miss out on rare examples, or only see them once making learning slow. We also note that WIS-Batch is unable to learn in the hardest of settings for the Markov chain, potentially due to the bias incurred from only performing WIS on a subsample of the entire data. One interesting observation is in the Baird’s Star Problem where IR results in better weights and lower value error (see appendix).
+
+![](images/0734802ee27e4ef295c1cae54745c60ca6cada3b32d998f013593971f64b5cbd.jpg)  
+Figure 3: left Markov Chain Random Walk with $n \ = \ 1 5 0 0 0$ , $b ~ = ~ 1 6$ , $\mu = [ 0 . 9 9 , 0 . 0 1 ] , \pi =$ $\left[ 0 . 0 1 , 0 . 9 9 \right]$ , optimal learning rates from above parameter study center Four rooms environment $n = 1 0 0 0 0$ , $b = 3 2$ with optimal settings from below parameter studies. We report $7 0 \%$ confidence bands for ease of comparison. right Torcs racing car simulator learning curves of RMSRE calculated over a pre-collected evaluation set. $\alpha _ { \mathrm { B C - I R } } ~ = ~ 1 e ^ { - 4 } , \alpha _ { \mathrm { I R } } ~ = ~ 1 e ^ { - 4 } , \overline { { { \alpha } } } _ { \mathrm { I S } } ~ = ~ 1 e ^ { - 6 }$ selected from a parameter study using RMSProp and the NVIDIA network designed for self-driving cars (Bojarski et al., 2016)
+
+The experiments in the Torcs domain show faster learning using a deep learning system. While the results are promising, they are not as stark as we would have expected given the prior experiments and the variance in final performance is much larger for BC-IR and IR. There are several contributing factors to learning off-policy using IR and IS that need to be considered. First by using RMSProp or other adaptive learning rate algorithms we are potentially gaining WIS like benefits, reducing the variance of the updates considerably. IR may improve performance when the behaviour and target policies cause even more variant importance ratios, but with an adaptive learning rate algorithm this becomes less problematic when using IS. More needs to be understood about the interactions between adaptive algorithms and off-policy learning with importance sampling ratios.
+
+# 5 CONCLUSIONS
+
+Resampling for off-policy learning has been unconsidered, to our knowledge, up until now. This may be due to a focus on learning from only the most recent experiences and throwing away transitions once used. The resampling approach is now viable because of the increased prominence of the experience replay buffer in deep reinforcement learning. Previous approaches have exploited the experience replay buffer for orthogonal purposes including Prioritized Experience Replay (Schaul et al., 2015b), which prioritizes training examples according to the temporal difference error $w _ { i } =$ $| \delta _ { i } | + \epsilon$ . A possible extension to IR is to sample from an intermediate sampling distribution which eases high variant importance sampling ratios (see Appendix B.5).
+
+In this paper we introduced a new approach to off-policy learning: resampling. We explored the theoretical implications of importance resampling, including a correction term to guarantee consistency in the moving window setting. We provided a number of empirical studies in hard off-policy learning settings outperforming the realistic competitors often by a wide margin, while also being less sensitive to learning rate in the mini-batch stochastic gradient update. We found IR to outperform IS in cases with potentially high importance sampling ratios suggesting a possible reduction in variance. Finally, we show improvements in learning rate performance for IR and BC-IR methods using deep learning within a challenging racing car simulator environment. There remains a number of both theoretical and empirical questions surrounding the benefits of the resampling approach to off-policy learning worth exploring in future work.
+
+# REFERENCES
+
+Sigrun Andradottir, Daniel P Heyman, and Teunis J Ott. On the Choice of Alternative Measures in Importance Sampling with Markov Chains. Operations Research, 1995.
+
+M S Arulampalam, S Maskell, N Gordon, and T Clapp. A Tutorial on Particle Filters for Online Nonlinear/Non-Gaussian Bayesian Tracking. IEEE Transactions on Signal Processing, 2002.
+
+Leemon Baird. Residual Algorithms: Reinforcement Learning with Function Approximation. In Machine Learning Proceedings 1995. 1995.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016.
+
+Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymir Mnih, Tom Ward, Yotam ´ Doron, Vlad Firoiu, Tim Harley, Iain Dunning, and others. IMPALA: Scalable distributed DeepRL with importance weighted actor-learner architectures. arXiv preprint arXiv:1802.01561, 2018.
+
+N J Gordon, D J Salmond, Radar, AFM Smith IEE Proceedings F Signal, and 1993. Novel approach to nonlinear/non-Gaussian Bayesian state estimation. IET, 1993.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement Learning with Unsupervised Auxiliary Tasks. In International Conference on Representation Learning, 2017.
+
+H Kahn and A W Marshall. Methods of Reducing Sample Size in Monte Carlo Computations. Journal of the Operations Research Society of America, 1953.
+
+Augustine Kong, Jun S Liu, and Wing Hung Wong. Sequential imputations and Bayesian missing data problems. Journal of the American Statistical Association, 1994.
+
+Long-Ji Lin. Self-Improving Reactive Agents Based On Reinforcement Learning, Planning and Teaching. Machine Learning, 1992.
+
+Long-Ji Lin. Reinforcement Learning for Robots Using Neural Networks. PhD thesis, Carnegie Mellon University, 1993.
+
+Victoria Lopez, Alberto Fernandez, Salvador Garcia, Vasile Palade, and Francisco Herrera. An insight into classification with imbalanced data: Empirical results and current trends on using data intrinsic characteristics. Information Sciences, 2013.
+
+A R Mahmood and R.S. Sutton. Off-policy learning based on weighted importance sampling with linear computational complexity. In Conference on Uncertainty in Artificial Intelligence, 2015.
+
+A Rupam Mahmood, Hado P van Hasselt, and Richard S Sutton. Weighted importance sampling for off-policy learning with linear function approximation. In Advances in Neural Information Processing Systems, 2014.
+
+Ashique Rupam Mahmood, Huizhen Yu, and Richard S Sutton. Multi-step Off-policy Learning Without Importance Sampling Ratios. arXiv:1509.01240v2, 2017.
+
+Luca Martino, V´ıctor Elvira, and Francisco Louzada. Effective sample size for importance sampling based on discrepancy measures. Signal Processing, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 2015.
+
+Joseph Modayil, Adam White, and Richard S Sutton. Multi-timescale nexting in a reinforcement learning robot. Adaptive Behavior - Animals, Animats, Software Agents, Robots, Adaptive Systems, 2014.
+
+Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc G Bellemare. Safe and Efficient Off- ´ Policy Reinforcement Learning. Advances in Neural Information Processing Systems, 2016.
+
+Art B. Owen. Monte Carlo theory, methods and examples. 2013.
+
+Doina Precup, Richard S Sutton, and Satinder P Singh. Eligibility Traces for Off-Policy Policy Evaluation. ICML, 2000.
+
+Doina Precup, Richard S Sutton, and Sanjoy Dasgupta. Off-Policy Temporal-Difference Learning with Function Approximation. ICML, 2001.
+
+Donald B Rubin. Using the SIR algorithm to simulate posterior distributions. Bayesian statistics, 1988.
+
+Reuven Y Rubinstein and Dirk P Kroese. Simulation and the Monte Carlo Method. John Wiley & Sons, 2016.
+
+Tom Schaul and Mark Ring. Better generalization with forecasts. In International Joint Conference on Artificial Intelligence, 2013.
+
+Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal Value Function Approximators. In International Conference on Machine Learning, 2015a.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized Experience Replay. arXiv:1511.05952 [cs], 2015b.
+
+David Silver, Hado van Hasselt, Matteo Hessel, Tom Schaul, Arthur Guez, Tim Harley, Gabriel Dulac-Arnold, David P Reichert, Neil C Rabinowitz, Andre Barreto, and Thomas Degris. The ´ Predictron - End-To-End Learning and Planning. In AAAI Conference on Artificial Intelligence, 2017.
+
+Øivind Skare, Erik Bølviken, and Lars Holden. Improved Sampling-Importance Resampling and Reduced Bias Importance Sampling. Scandinavian Journal of Statistics, 2003.
+
+AFM Smith, AE Gelfand The American Statistician, and 1992. Bayesian statistics without tears: a sampling–resampling perspective. Taylor & Francis, 1992.
+
+Martin Stolle and Doina Precup. Learning Options in Reinforcement Learning. In International Symposium on Abstraction, Reformulation, and Approximation, 2002.
+
+Richard S Sutton and Andrew G Barto. Reinforcement Learning: An Introduction - Draft. MIT Press, 2018.
+
+Richard S Sutton, Doina Precup, and Satinder Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 1999.
+
+Richard S Sutton, Eddie J Rafols, and Anna Koop. Temporal Abstraction in Temporal-difference Networks. In Advances in Neural Information Processing Systems, 2005.
+
+Richard S Sutton, H Maei, D Precup, and S Bhatnagar. Fast gradient-descent methods for temporaldifference learning with linear function approximation. In International Conference on Machine Learning, 2009.
+
+Richard S Sutton, J Modayil, M Delp, T Degris, P.M. Pilarski, A White, and D Precup. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In International Conference on Autonomous Agents and Multiagent Systems, 2011.
+
+Philip Thomas and Emma Brunskill. Data-Efficient Off-Policy Policy Evaluation for Reinforcement Learning. In AAAI Conference on Artificial Intelligence, 2016.
+
+Philip S Thomas and Emma Brunskill. Importance Sampling with Unequal Support. In AAAI Conference on Artificial Intelligence, 2017.
+
+# A WEIGHTED IMPORTANCE SAMPLING
+
+We consider three weighted importance sampling updates as competitors to IR. $N$ is the size of the experience replay buffer, $b$ is the size of a single batch.
+
+WIS-Batch
+
+$$
+\begin{array} { r l } & { \Delta \theta = \frac { \sum _ { i } ^ { b } \rho _ { i } \delta _ { i } \nabla _ { \theta } V \left( s _ { i } ; \theta \right) } { \sum _ { j } ^ { b } \rho _ { j } } } \\ & { \Delta \theta = N \frac { \sum _ { i } ^ { b } \rho _ { i } \delta _ { i } \nabla _ { \theta } V \left( s _ { i } ; \theta \right) } { \sum _ { j } ^ { N } \rho _ { j } } } \\ & { \Delta \theta = \frac { \sum _ { i } ^ { N } \rho _ { i } \delta _ { i } \nabla _ { \theta } V \left( s _ { i } ; \theta \right) } { \sum _ { j } ^ { N } \rho _ { j } } } \end{array}
+$$
+
+WIS-Buffer
+
+WIS-Optimal
+
+# B MORE EXPERIMENTAL RESULTS
+
+# B.1 MARKOV CHAIN
+
+![](images/9da6c321bbbbbd8ead1fa8bf6a0fea1872e17fa4649168cba4df27ffb41dc8da.jpg)  
+Figure 4: Markov Chain results for V-Trace and Sarsa. Four clipping parameters were chosen with different amounts of aggressiveness. They were calculated from the known max importance sampling value, multiplied by the scalars 0.5 and 0.9. We also included a clipping value of 1.0 which is consistent with the recommendations made for retrace. The error for Sarsa was calculated by deriving the state-value function from the current action-state value function, and following the same error calculation as with the other methods.
+
+We also include results in the random walk markov chain for V-Trace and Sarsa. V-Trace exhibited the same issues as importance sampling, where we can see a clear disadvantage in the harder policies. Also, we can clearly see a bias-variance trade off in V-Trace as the clipping parameter $\bar { \rho }$ became more aggressive. Sarsa makes clear gains over $\mathrm { E R + I S }$ (and IR in the easiest setting), but fails to learn the true value function for the hardest settings.
+
+# B.2 BAIRD’S STAR PROBLEM
+
+We use a well known variant of the Star Problem (Baird, 1995; Sutton et al., 2009) proposed as a counter example to the convergence of semi-gradient temporal difference learning in the off-policy setting. We train using a batch version of TDC (Sutton et al., 2009). We calculate the RMSVE for each state on every training step.
+
+# B.3 FOUR ROOMS DOMAIN
+
+We also sampled new random states in which to act unfavorably for every run. We found the behavior used in the experiments presented in the main text to be harder than many of the other policies sampled randomly.
+
+![](images/5f1521f986a544af3d7659be89e13937e6ceebf879f467627c30db231e6d2895.jpg)  
+Figure 5: Baird’s Star Problem.
+
+![](images/e68fd8c360f7e4ee6415ea86397db78b1f34d7bcc613ab2c8e2823adb3f0eebd.jpg)  
+Figure 6: Four rooms experiments for new random states every run: left Learning rate sensitivity center Buffer Size Sensitivity right Learning Curves
+
+# B.4 MOUNTAIN CAR
+
+We use the standard mountain car domain described in (Sutton and Barto, 2018). To make the simulations more realistic we collect experience from behavior policy learned through Q-learning (Sutton and Barto, 2018) with a $\epsilon$ -greedy exploration strategy. We code a GVF to predict whether the agent will hit the back wall within a horizon of $\gamma = 0 . 9$ while following the the persistent policy accelerating forward. We use two exploration parameters $\epsilon = \{ 0 . 1 , 0 . 5 \}$ with maximum importance sampling ratio values at $\rho _ { m a x } = \{ 6 , 3 0 \}$ respectively.
+
+We show comparisons for both a static step size SGD and with the Adam optimizer. These experiments perform as expected, except for one configuration of the behavior policy using the Adam optimizer. It is possible that the Adam optimizer is getting some benefit similar to WIS with the recency averages of updates accounting for the high variance of the update.
+
+![](images/c72d930bad65fa8a144d87bc95d2fd6e172b6992fbf11368fcf2f479730df304.jpg)
+
+![](images/3e9abe76e66d058b2ceca2e258717238db82cf8e57579a158267ce7e11a57870.jpg)  
+Figure 7: Mountain Car: Mini-batch Gradient Descent with constant learning rate $\pi =$ $[ 0 \bar { , } 0 , 1 . 0 ] , | B | = 5 0 0 0 0$ , Left $\epsilon = 0 . 1$ , Right $\epsilon = 0 . 5$
+
+# B.5 SAMPLING ACCORDING TO INTERMEDIATE POLICIES
+
+While intuitively it might seem sampling according to the target policy will produce the best value functions, when making multiple predictions with the same training network it would be more convenient to sample from the experience replay buffer with an intermediate policy. We get the benefits of less variant importance sampling ratios with the ability to use one IR buffer for multiple policies.
+
+![](images/3c7869c8680f39a13d34871059b4209fc7eab38053a880dee6ae0b1fb45c6cde.jpg)  
+Figure 8: Mountain Car: Mini-batch Gradient Descent with Adam Optimizer. $\mathbf { X }$ -axis: learning rates, y-axis: RMSVE $\pi = [ 0 , 0 , 1 . 0 ]$ , $| B | = 5 0 0 0 0$ , Left $\epsilon = 0 . 1$ , Right $\epsilon = 0 . 5$
+
+![](images/2e970eccd6e0549dd9eeb497bc5cde85ba55c4120ef9299c050e11f19551902f.jpg)  
+Figure 9: Mountain Car left Learning curve for optimal settings for Adam optimizer $\mathbf { X }$ -axis: time $( 1 0 ^ { 4 } )$ y-axis: RMSVE center Early example of learned predictions $\mathbf { X }$ -axis: Time y-axis: Prediction right Late example of learned predictions $\mathbf { X }$ -axis: Time, y-axis: Prediction
+
+To combine the IR and importance sampling with a uniform experience replay we sample from the buffer according to the PMF
+
+$$
+p ( \mathrm { s a m p l i n g \ : } d _ { i } ) = \frac { \bar { \rho } _ { i } } { \sum _ { j } \bar { \rho } _ { j } } , \qquad \bar { \rho } _ { i } = \frac { \pi _ { s a m p l e } ( a _ { t } | s _ { t } ) } { \mu ( a _ { t } | s _ { t } ) } .
+$$
+
+We would then us off-policy temporal difference methods with the effective importance sampling ratio used as ρeffective $\begin{array} { r } { \rho _ { \mathrm { e f f e c t i v e } } = \overbar { \frac { \pi ( a _ { t } | s _ { t } ) } { \pi _ { s a m p l e } ( a _ { t } | s _ { t } ) } } } \end{array}$ . We show initial results for this extension in the markov chain random walk in figure 10.
+
+![](images/70d15713995c97393356a8070e26a408b9be3f225a38249a667b6ec6437c1d83.jpg)  
+Figure 10: Intermediate sampling policies in a random walk markov chain. (left) $\pi = [ 0 . 1 , 0 . 9 ] , \mu =$ [0.9, 0.1], (right) $\pi = [ 0 . 0 1 , 0 . 9 9 ]$ , $\mu = [ 0 . 9 9 , 0 . 0 1 ]$
+
+# C MORE THEORETICAL RESULTS
+
+# C.1 CONSISTENCY OF THE IR ESTIMATOR WITH GROWING BUFFER SIZE
+
+We show the consistency of the IR estimator with $n \to \infty$ for convenience, but our approach closely follows that of (Smith et al., 1992).
+
+Theorem C.1. Let $B = \{ x _ { 1 } , x _ { 2 } , . . . , x _ { n } \}$ be a buffer of data sampled i.i.d. according to proposal distribution $p ( x )$ . Let $q ( x )$ be some distribution of interest and assume the proposal distribution samples everywhere where $\overset { \cdot } { q } ( x )$ is non-zero. Also, let $Y$ be a discrete random variable taking values $x _ { i }$ with probability $\propto \frac { q ( x _ { i } ) } { p ( x _ { i } ) }$ .
+
+Then, $Y$ converges in distribution to $X \sim Q$ as $n \to \infty$
+
+Proof. Let $\begin{array} { r } { \rho _ { i } = \frac { q ( x _ { i } ) } { p ( x _ { i } ) } } \end{array}$ . From the probability mass function of $Y$ , we have that:
+
+$$
+\begin{array} { r l } { \mathbb { P } [ Y \leq a ] = \displaystyle \sum _ { i = 1 } ^ { n } \mathbb { P } [ Y = x _ { i } ] \mathbb { I } \{ x _ { i } \leq a \} } \\ { = \frac { n ^ { - 1 } \sum _ { i = 1 } ^ { n } \rho _ { i } \mathbb { I } \{ x _ { i } \leq a \} } { n ^ { - 1 } \sum _ { i = 1 } ^ { n } \rho _ { i } } } \\ { \frac { n ^ { - \alpha } \rho _ { i } \mathbb { P } ( x ) \mathbb { I } \{ x \leq a \} ] } { \mathbb { E } _ { q } [ \rho ( x ) ] } } \\ { = \frac { 1 - \int _ { - \infty } ^ { \alpha } \frac { q ( x ) } { \rho ( x ) } p ( x ) d x + 0 \cdot \int _ { a } ^ { \infty } \frac { q ( x ) } { \rho ( x ) } p ( x ) d x } { \int _ { - \infty } ^ { \infty } \frac { q ( x ) } { \rho ( x ) } p ( x ) d x } } \\ { = \int _ { - \infty } ^ { a } q ( x ) d x } \end{array}
+$$
+
+The above shows consistency. If we have a large enough buffer, then the importance resampling will closely approximate sampling from the target distribution $Q$ . In particular, any expectation we want to estimate under $Q$ can also be a well-approximated by using the defined sampling scheme.
+
+# C.2 CHANGING BEHAVIOUR POLICIES
+
+We consider the importance sampling estimator under conditions of a changing policy.
+
+Theorem C.2. Let $P$ be a target distribution with density $p$ and $\{ x _ { i } \} _ { i = 1 } ^ { n }$ be a dataset where each $x _ { i }$ is sampled from $P _ { i }$ independently. Then, the weighted importance sampling estimator $\hat { \mu } =$ $\scriptstyle \sum _ { i = 1 } ^ { n } { \frac { \rho _ { i } } { \sum _ { j = 1 } ^ { n } \rho _ { j } } } g ( x _ { i } )$ is consistent for $\mathbb { E } _ { f } [ g ( X ) ]$ where $g ( . )$ is a function of interest and $\begin{array} { r } { \rho _ { i } = \frac { q ( x _ { i } ) } { p _ { i } ( x _ { i } ) } } \end{array}$
+
+Proof. First, we rewrite $\begin{array} { r } { \hat { \mu } = \frac { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \rho _ { i } g ( x _ { i } ) } { \frac { 1 } { n } \sum _ { j = 1 } ^ { n } \rho _ { j } } } \end{array}$ and let $Y _ { i } = \rho _ { i } g ( x _ { i } )$ .
+
+Next, we find the expectations of $Y _ { i }$ and $\rho _ { i }$
+
+$$
+\begin{array} { c l c r } { { \displaystyle \mathbb { E } _ { p _ { i } } [ Y _ { i } ] = \int \frac { q ( \boldsymbol { x } ) } { p _ { i } ( \boldsymbol { x } ) } g ( \boldsymbol { x } ) p _ { i } ( \boldsymbol { x } ) d \boldsymbol { x } } } \\ { { = \mathbb { E } _ { q } [ g ( \boldsymbol { X } ) ] } } \end{array}
+$$
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } _ { p _ { i } } [ \rho _ { i } ] = \int \frac { q ( { \boldsymbol x } ) } { p _ { i } ( { \boldsymbol x } ) } p _ { i } ( { \boldsymbol x } ) d { \boldsymbol x } } \\ { \displaystyle = \int q ( { \boldsymbol x } ) d { \boldsymbol x } } \\ { \displaystyle = 1 } \end{array}
+$$
+
+Finally, since all $Y _ { i }$ and all $\rho _ { i }$ have the same expectation and are independent, we apply the law of large numbers to obtain that
+
+$$
+\hat { \mu } = \frac { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \rho _ { i } g ( x _ { i } ) } { \frac { 1 } { n } \sum _ { j = 1 } ^ { n } \rho _ { j } } \xrightarrow [ ] { n \to \infty } \frac { { \mathbb E } _ { q } [ g ( X ) ] } { ( 1 ) }
+$$
+
+as desired.
+
+Theorem C.2 implies that, even if the behaviour policy is changing over time, as long as we use an importance ratio corresponding to the policy that was used to select an action, we will retain an unbiased estimate of the expected update.
+
+# C.3 CONSISTENCY UNDER A SLIDING WINDOW DATASET
+
+Lemma C.3. Let $Z _ { 1 } , . . . Z _ { n }$ be random variables with mean $\mu$ . Suppose there exists a $c > 0$ such that $\mathbb { V } ( Z _ { i } ) \le c \ \forall i$ and that $\begin{array} { r } { \operatorname* { l i m } _ { | i - j | \to \infty } \operatorname { C o v } ( X _ { i } , X _ { j } ) = 0 } \end{array}$ .   
+Then, as N → ∞, 1N PNi=1 Zi converges in probability to µ.
+
+Proof. Let $\begin{array} { r } { S _ { N } = \sum _ { i = 1 } ^ { N } Z _ { i } } \end{array}$
+
+$$
+\mathbb { V } ( S _ { N } ) = \sum _ { i = 1 } ^ { N } \mathbb { V } ( Z _ { i } ) + 2 \sum _ { i = 1 } ^ { N } \sum _ { j = i + 1 } ^ { N } \operatorname { C o v } ( Z _ { i } , Z _ { j } )
+$$
+
+The first term is bounded by $c N$ from our assumption on the variance. Now, to bound the second term.
+
+Fix $\delta > 0$ and choose $M$ such that $\forall | i - j | > M$ , $| \mathrm { C o v } ( Z _ { i } , Z _ { j } ) | < \delta$ (such an $M$ must exist since $\begin{array} { r } { \operatorname* { l i m } _ { | i - j | \to \infty } \operatorname { C o v } ( X _ { i } , X _ { j } ) = 0 ) } \end{array}$ . Assuming that $N > M$ , we can decompose the second term into
+
+$$
+\begin{array} { r l } & { \displaystyle \sum _ { i = 1 } ^ { N } \sum _ { j = i + 1 } ^ { N } \mathrm { C o v } ( Z _ { i } , Z _ { j } ) = \sum _ { i = 1 } ^ { N } \sum _ { j = i + 1 } ^ { i + M } \mathrm { C o v } ( Z _ { i } , Z _ { j } ) + \sum _ { i = 1 } ^ { N } \sum _ { j = i + M + 1 } ^ { N } \mathrm { C o v } ( Z _ { i } , Z _ { j } ) } \\ & { \displaystyle \left| \sum _ { i = 1 } ^ { N } \sum _ { j = i + 1 } ^ { N } \mathrm { C o v } ( Z _ { i } , Z _ { j } ) \right| \leq \sum _ { i = 1 } ^ { N } \sum _ { j = i + 1 } ^ { i + M } | \mathrm { C o v } ( Z _ { i } , Z _ { j } ) | + \sum _ { i = 1 } ^ { N } \sum _ { j = i + M + 1 } ^ { N } | \mathrm { C o v } ( Z _ { i } , Z _ { j } ) | } \end{array}
+$$
+
+By the Cauchy-Schwarz inequality and our variance assumption, $| \mathrm { C o v } ( Z _ { i } , Z _ { j } ) | \le c$ . So, we get
+
+$$
+\begin{array} { r } { \left| \displaystyle \sum _ { i = 1 } ^ { N } \displaystyle \sum _ { j = i + 1 } ^ { N } \mathrm { C o v } ( Z _ { i } , Z _ { j } ) \right| \le \displaystyle \sum _ { i = 1 } ^ { N } \displaystyle \sum _ { j = i + 1 } ^ { i + M } c + \displaystyle \sum _ { i = 1 } ^ { N } \sum _ { j = i + M + 1 } ^ { N } \delta } \\ { \le N M c + N ^ { 2 } \delta } \end{array}
+$$
+
+Altogether, our upper bound is
+
+$$
+\mathbb { V } \left( \frac { S _ { N } } { N } \right) \le \frac { c } { N } + \frac { M c } { N } + \delta
+$$
+
+Finally, we apply Chebyshev’s inequality. For a fixed $\epsilon > 0$ ,
+
+$$
+\begin{array} { l } { \displaystyle { P \left( \left| \frac { S _ { N } } { N } - \mu \right| > \epsilon \right) \le \frac { 1 } { \epsilon ^ { 2 } } \mathbb { V } \left( \frac { S _ { N } } { N } \right) } } \\ { \displaystyle { \le \frac { 1 } { \epsilon ^ { 2 } } \left( \frac { c } { N } + \frac { M c } { N } + \delta \right) } } \end{array}
+$$
+
+Since we can choose $\delta$ to be arbitrarily small (say $\begin{array} { r } { \delta = \frac { 1 } { N } , } \end{array}$ ), the right-hand side goes to $0$ as $N \to \infty$ , concluding the proof.

parse/train/rJxDkvqee/rJxDkvqee.md

@@ -0,0 +1,279 @@
+# MULTI-VIEW RECURRENT NEURALACOUSTIC WORD EMBEDDINGS
+
+# Wanjia He
+
+Department of Computer Science University of Chicago Chicago, IL 60637, USA wanjia@ttic.edu
+
+Weiran Wang & Karen Livescu Toyota Technological Institute at Chicago Chicago, IL 60637, USA {weiranwang,klivescu}@ttic.edu
+
+# ABSTRACT
+
+Recent work has begun exploring neural acoustic word embeddings—fixeddimensional vector representations of arbitrary-length speech segments corresponding to words. Such embeddings are applicable to speech retrieval and recognition tasks, where reasoning about whole words may make it possible to avoid ambiguous sub-word representations. The main idea is to map acoustic sequences to fixed-dimensional vectors such that examples of the same word are mapped to similar vectors, while different-word examples are mapped to very different vectors. In this work we take a multi-view approach to learning acoustic word embeddings, in which we jointly learn to embed acoustic sequences and their corresponding character sequences. We use deep bidirectional LSTM embedding models and multi-view contrastive losses. We study the effect of different loss variants, including fixed-margin and cost-sensitive losses. Our acoustic word embeddings improve over previous approaches for the task of word discrimination. We also present results on other tasks that are enabled by the multi-view approach, including cross-view word discrimination and word similarity.
+
+# 1 INTRODUCTION
+
+Word embeddings—continuous-valued vector representations of words—are an almost ubiquitous component of recent natural language processing (NLP) research. Word embeddings can be learned using spectral methods (Deerwester et al., 1990) or, more commonly in recent work, via neural networks (Bengio et al., 2003; Mnih & Hinton, 2007; Mikolov et al., 2013; Pennington et al., 2014). Word embeddings can also be composed to form embeddings of phrases, sentences, or documents (Socher et al., 2014; Kiros et al., 2015; Wieting et al., 2016; Iyyer et al., 2015).
+
+In typical NLP applications, such embeddings are intended to represent the semantics of the corresponding words/sequences. In contrast, embeddings that represent the way a word or sequence sounds are rarely considered. In this work we address this problem, starting with embeddings of individual words. Such embeddings could be useful for tasks like spoken term detection (Fiscus et al., 2007), spoken query-by-example search (Anguera et al., 2014), or even speech recognition using a whole-word approach (Gemmeke et al., 2011; Bengio & Heigold, 2014). In tasks that involve comparing speech segments to each other, vector embeddings can allow more efficient and more accurate distance computation than sequence-based approaches such as dynamic time warping (Levin et al., 2013, 2015; Kamper et al., 2016; Settle & Livescu, 2016; Chung et al., 2016).
+
+We consider the problem of learning vector representations of acoustic sequences and orthographic (character) sequences corresponding to single words, such that the learned embeddings represent the way the word sounds. We take a multi-view approach, where we jointly learn the embeddings for character and acoustic sequences. We consider several contrastive losses, based on learning from pairs of matched acoustic-orthographic examples and randomly drawn mismatched pairs. The losses correspond to different goals for learning such embeddings; for example, we might want the embeddings of two waveforms to be close when they correspond to the same word and far when they correspond to different ones, or we might want the distances between embeddings to correspond to some ground-truth orthographic edit distance.
+
+One of the useful properties of this multi-view approach is that, unlike earlier work on acoustic word embeddings, it produces both acoustic and orthographic embeddings that can be directly compared. This makes it possible to use the same learned embeddings for multiple single-view and cross-view tasks. Our multi-view embeddings produce improved results over earlier work on acoustic word discrimination, as well as encouraging results on cross-view discrimination and word similarity.1
+
+# 2 OUR APPROACH
+
+In this section, we first introduce our approach for learning acoustic word embeddings in a multiview setting, after briefly reviewing related approaches to put ours in context. We then discuss the particular neural network architecture we use, based on bidirectional long short-term memory (LSTM) networks (Hochreiter & Schmidhuber, 1997).
+
+# 2.1 MULTI-VIEW LEARNING OF ACOUSTIC WORD EMBEDDINGS
+
+Previous approaches have focused on learning acoustic word embeddings in a “single-view” setting. In the simplest approach, one uses supervision of the form “acoustic segment $\mathbf { x }$ is an instance of the word dataset oing optim $\mathbf { y } ^ { \mathsf { , , } \mathsf { , } }$ , and trains the embedding to be discriired acoustic segments and word labels tion: word identity. Formally, given a, this approach solves the follow$\{ ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ) \} _ { i = 1 } ^ { N }$
+
+$$
+\operatorname* { m i n } _ { f , h } { \mathrm { \ o b j } _ { c l a s s i f y } } : = \frac { 1 } { N } \sum _ { i } ^ { N } \ell \left( h ( f ( \mathbf { x } _ { i } ) ) , \mathbf { y } _ { i } \right) ,
+$$
+
+where network $f$ maps an acoustic segment into a fixed-dimensional feature vector/embedding, $h$ is a classifier that predicts the corresponding word label from the label set of the training data, and the loss $\ell$ measures the discrepancy between the prediction and ground-truth word label (one can use any multi-class classification loss here, and a typical choice is the cross-entropy loss where $h$ has a softmax top layer). The two networks $f$ and $h$ are trained jointly. Equivalently, one could consider the composition $h ( f ( \mathbf { x } ) )$ as a classifier network, and use any intermediate layer’s activations as the features. We refer to the objective in (1) as the “classifier network” objective, which has been used in several prior studies on acoustic word embeddings (Bengio & Heigold, 2014; Kamper et al., 2016; Settle & Livescu, 2016).
+
+This objective, however, is not ideal for learning acoustic word embeddings. This is because the set of possible word labels is huge, and we may not have enough instances of each label to train a good classifier. In downstream tasks, we may encounter acoustic segments of words that did not appear in the embedding training set, and it is not clear that the classifier-based embeddings will have reasonable behavior on previously unseen words.
+
+An alternative approach, based on Siamese networks (Bromley et al., 1993), uses supervision of the form “segment $\mathbf { \dot { x } } ^ { \hat { 1 } }$ is similar to segment $\mathbf { x } ^ { 2 }$ , and is not similar to segment $\mathbf { x } ^ { 3 } \mathbf { \ ' }$ ”, where two segments are considered similar if they have the same word label and dissimilar otherwise. Models based on Siamese networks have been used for a variety of representation learning problems in NLP $\mathrm { H u }$ et al., 2014; Wieting et al., 2016), vision (Hadsell et al., 2006), and speech (Synnaeve et al., 2014; Kamper et al., 2015) including acoustic word embeddings (Kamper et al., 2016; Settle & Livescu, 2016). A typical objective in this category enforces that the distance between $( \mathbf { x } ^ { 1 } , \mathbf { x } ^ { 3 } )$ is larger than the distance between $( \mathbf { x } ^ { 1 } , \mathbf { x } ^ { 2 } )$ by some margin:
+
+$$
+\operatorname* { m i n } _ { f } \ \mathrm { o b j } _ { s i a m e s e } : = \frac { 1 } { N } \sum _ { i } ^ { N } \operatorname* { m a x } \left( 0 , \ m + d i s \left( f ( \mathbf { x } _ { i } ^ { 1 } ) , \ f ( \mathbf { x } _ { i } ^ { 2 } ) \right) - d i s \left( f ( \mathbf { x } _ { i } ^ { 1 } ) , \ f ( \mathbf { x } _ { i } ^ { 3 } ) \right) \right) ,
+$$
+
+where the network $f$ extracts the fixed-dimensional embedding, the distance function $d i s \left( \cdot , \cdot \right)$ measures the distance between the two embedding vectors, and $m > 0$ is the margin parameter. The term “Siamese” (Bromley et al., 1993; Chopra et al., 2005) refers to the fact that the triplet $( \mathbf { x } ^ { 1 } , \mathbf { x } ^ { 2 } , \mathbf { x } ^ { 3 } )$ share the same embedding network $f$ .
+
+Unlike the classification-based loss, the Siamese network loss does not enforce hard decisions on the label of each segment. Instead it tries to learn embeddings that respect distances between word pairs, which can be helpful for dealing with unseen words. The Siamese network approach also uses more examples in training, as one can easily generate many more triplets than (segment, label) pairs, and it is not limited to those labels that occur a sufficient number of times in the training set.
+
+The above approaches treat the word labels as discrete classes, which ignores the similarity between different words, and does not take advantage of the more complex information contained in the character sequences corresponding to word labels. The orthography naturally reflects some aspects of similarity between the words’ pronunciations, which should also be reflected in the acoustic embeddings. One way to learn features from multiple sources of complementary information is using a multi-view representation learning setting. We take this approach, and consider the acoustic segment and the character sequence to be two different views of the pronunciation of the word.
+
+While many deep multi-view learning objectives are applicable (Ngiam et al., 2011; Srivastava & Salakhutdinov, 2014; Sohn et al., 2014; Wang et al., 2015), we consider the multi-view contrastive loss objective of (Hermann & Blunsom, 2014), which is simple to optimize and implement and performs well in practice. In this algorithm, we embed acoustic segments $\mathbf { x }$ by a network $f$ and character label sequences c by another network $g$ into a common space, and use weak supervision of the form “for paired segment $\mathbf { x } ^ { + }$ and its character label sequence $\mathbf { c } ^ { + }$ , the distance between their embedding is much smaller than the distance between embeddings of $\mathbf { x } ^ { + }$ and an unmatched character label sequence $\mathbf { c } ^ { - , }$ ”. Formally, we optimize the following objective with such supervision:
+
+$$
+\operatorname* { m i n } _ { f , g } \mathrm { ~ o b j } ^ { 0 } : = \frac { 1 } { N } \sum _ { i } ^ { N } \operatorname* { m a x } \left( 0 , m + d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , g ( \mathbf { c } _ { i } ^ { + } ) \right) - d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , g ( \mathbf { c } _ { i } ^ { - } ) \right) \right) ,
+$$
+
+where $\mathbf { c } _ { i } ^ { - }$ is a negative character label sequence of $\mathbf { x } _ { i } ^ { + }$ to be contrasted with the positive/correct character sequence ${ \mathbf { c } } _ { i } ^ { + }$ , and $m$ is the margin parameter. In this paper we use the cosine distance, $\begin{array} { r } { d i s \left( \mathbf { a } , \mathbf { b } \right) = 1 - \bigg \langle \frac { \mathbf { a } } { \left\| \mathbf { a } \right\| } , \ \frac { \mathbf { b } } { \left\| \mathbf { b } \right\| } \bigg \rangle . ^ { 2 } } \end{array}$
+
+Note that in the multi-view setting, we have multiple ways of generating triplets that contain one positive pair and one negative pair each. Below are the other three objectives we explore in this paper:
+
+$$
+\begin{array} { r l r } & { \underset { f , g } { \operatorname* { m i n } \mathrm { ~ o b j } } ^ { 1 } : = \frac { 1 } { N } \sum _ { i } ^ { N } \operatorname* { m a x } \left( 0 , m + d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , g ( \mathbf { c } _ { i } ^ { + } ) \right) - d i s \left( g ( \mathbf { c } _ { i } ^ { + } ) , g ( \mathbf { c } _ { i } ^ { - } ) \right) \right) , } & \\ & { \underset { f , g } { \operatorname* { m i n } \mathrm { ~ o b j } } ^ { 2 } : = \frac { 1 } { N } \sum _ { i } ^ { N } \operatorname* { m a x } \left( 0 , m + d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , g ( \mathbf { c } _ { i } ^ { + } ) \right) - d i s \left( f ( \mathbf { x } _ { i } ^ { - } ) , g ( \mathbf { c } _ { i } ^ { + } ) \right) \right) , } & \\ & { \underset { f , g } { \operatorname* { m i n } \mathrm { ~ o b j } } ^ { 3 } : = \frac { 1 } { N } \sum _ { i } ^ { N } \operatorname* { m a x } \left( 0 , m + d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , g ( \mathbf { c } _ { i } ^ { + } ) \right) - d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , f ( \mathbf { x } _ { i } ^ { - } ) \right) \right) . } \end{array}
+$$
+
+$\mathbf { x } _ { i } ^ { - }$ in (5) and (6) refers to a negative acoustic feature sequence, that is one with a different label from ${ \bf x } _ { i } ^ { + }$ . We note that $\mathrm { \ o b j } ^ { \mathrm { 1 } }$ and $\mathrm { o b j } ^ { 3 }$ contain distances between same-view embeddings, and are less thoroughly explored in the literature. We will also consider combinations of obj0 through obj3.
+
+Finally, thus far we have considered losses that do not explicitly take into account the degree of difference between the positive and negative pairs (although the learned embeddings may implicitly learn this through the relationship between sequences in the two views). We also consider a costsensitive objective designed to explicitly arrange the embedding space such that word similarity is respected. In (3), instead of a fixed margin $m$ , we use:
+
+$$
+m ( { \bf c } ^ { + } , { \bf c } ^ { - } ) : = m _ { \mathrm { m a x } } \cdot \frac { \mathrm { m i n } \left( t _ { \mathrm { m a x } } , e d i t d i s ( { \bf c } ^ { + } , { \bf c } ^ { - } ) \right) } { t _ { \mathrm { m a x } } } ,
+$$
+
+where $t _ { \mathrm { m a x } } > 0$ is a threshold for edit distances (all edit distances above $t _ { \mathrm { m a x } }$ are considered equally bad), and $m _ { m a x }$ is the maximum margin we impose. The margin is set to $m _ { m a x }$ if the edit distance between two character sequences is above $t _ { \mathrm { m a x } }$ ; otherwise it scales linearly with the edit distance $e d i t d i s ( { \bf c } ^ { + } , { \bf c } ^ { - } ) )$ . We use the Levenshtein distance as the edit distance. Here we explore the costsensitive margin with $\mathrm { o b j } ^ { \mathrm { 0 } }$ , but it could in principle be used with other objectives as well.
+
+![](images/c3ff837397d39b835e1fc3d63562ed43f1f1a643589586c9893411912a989b7d.jpg)  
+Figure 1: Illustration of our embedding architecture and contrastive multi-view approach.
+
+# 2.2 RECURRENT NEURAL NETWORK ARCHITECTURE
+
+Since the inputs of both views have a sequential structure, we implement both $f$ and $g$ with recurrent neural networks and in particular long-short term memory networks (LSTMs). Recurrent neural networks are the state-of-the-art models for a number of speech tasks including speech recognition Graves et al. (2013), and LSTM-based acoustic word embeddings have produced the best results on one of the tasks in our experiments (Settle & Livescu, 2016).
+
+As shown in Figure 1, our $f$ and $g$ are produced by multi-layer (stacked) bidirectional LSTMs. The inputs can be any frame-level acoustic feature representation and vector representation of the characters in the orthographic input. At each layer, two LSTM cells process the input sequence from left to right and from right to left respectively. At intermediate layers, the outputs of the two LSTMs at each time step are concatenated to form the input sequence to the next layer. At the top layer, the last time step outputs of the two LSTMs are concatenated to form a fixed-dimensional embedding of the view, and the embeddings are then used to calculate the cosine distances in our objectives.
+
+# 3 RELATED WORK
+
+We are aware of no prior work on multi-view learning of acoustic and character-based word embeddings. However, acoustic word embeddings learned in other ways have recently begun to be studied. Levin et al. (2013) proposed an approach for embedding an arbitrary-length segment of speech as a fixed-dimensional vector, based on representing each word as a vector of dynamic time warping (DTW) distances to a set of template words. This approach produced improved performance on a word discrimination task compared to using raw DTW distances, and was later also applied successfully for a query-by-example task (Levin et al., 2015). One disadvantage of this approach is that, while DTW handles the issue of variable sequence lengths, it is computationally costly and involves a number of DTW parameters that are not learned.
+
+Kamper et al. (2016) and Settle & Livescu (2016) later improved on Levin et al.’s word discrimination results using convolutional neural networks (CNNs) and recurrent neural networks (RNNs) trained with either a classification or contrastive loss. Bengio & Heigold (2014) trained convolutional neural network (CNN)-based acoustic word embeddings for rescoring the outputs of a speech recognizer, using a loss combining classification and ranking criteria. Maas et al. (2012) trained a CNN to predict a semantic word embedding from an acoustic segment, and used the resulting embeddings as features in a segmental word-level speech recognizer. Harwath and Glass Harwath & Glass (2015); Harwath et al. (2016); Harwath & Glass (2017) jointly trained CNN embeddings of images and spoken captions, and showed that word-like unit embeddings can be extracted from the speech model. CNNs require normalizing the duration of the input sequences, which has typically been done via padding. RNNs, on the other hand, are more flexible in dealing with very different-length sequences. Chen et al. (2015) used long short-term memory (LSTM) networks with a classification loss to embed acoustic words for a simple (single-query) query-by-example search task. Chung et al. (2016) learned acoustic word embeddings based on recurrent neural network (RNN) autoencoders, and found that they improve over DTW for a word discrimination task similar to that of Levin et al. (2013). Audhkhasi et al. (2017) learned autoencoders for acoustic and written words, as well as a model for comparing the two, and applied these to a keyword search task.
+
+Evaluation of acoustic word embeddings in downstream tasks such as speech recognition and search can be costly, and can obscure details of embedding models and training approaches. Most evaluations have been based on word discrimination – the task of determining whether two speech segments correspond to the same word or not – which can be seen as a proxy for query-by-example search (Levin et al., 2013; Kamper et al., 2016; Settle & Livescu, 2016; Chung et al., 2016). One difference between word discrimination and search/recognition tasks is that in word discrimination the word boundaries are given. However, prior work has been able to apply results from word discrimination Levin et al. (2013) to improve a query-by-example system without known word boundaries Levin et al. (2015), by simply applying their embeddings to non-word segments as well.
+
+The only prior work focused on vector embeddings of character sequences explicitly aimed at representing their acoustic similarity is that of Ghannay et al. (2016), who proposed evaluations based on nearest-neighbor retrieval, phonetic/orthographic similarity measures, and homophone disambiguation. We use related tasks here, as well as acoustic word discrimination for comparison with prior work on acoustic embeddings.
+
+# 4 EXPERIMENTS AND RESULTS
+
+The ultimate goal is to gain improvements in speech systems where word-level discrimination is needed, such as speech recognition and query-by-example search. However, in order to focus on the content of the embeddings themselves and to more quickly compare a variety of models, it is desirable to have surrogate tasks that serve as intrinsic measures of performance. Here we consider three forms of evaluation, all based on measuring whether cosine distances between learned embeddings correspond well to desired properties.
+
+In the first task, acoustic word discrimination, we are given a pair of acoustic sequences and must decide whether they correspond to the same word or to different words. This task has been used in several prior papers on acoustic word embeddings Kamper et al. (2015, 2016); Chung et al. (2016); Settle & Livescu (2016) and is a proxy for query-by-example search. For each given spoken word pair, we calculate the cosine distance between their embeddings. If the cosine distance is below a threshold, we output “yes” (same word), otherwise we output “no” (different words). The performance measure is the average precision (AP), which is the area under the precision-recall curve generated by varying the threshold and has a maximum value of 1.
+
+In our multi-view setup, we embed not only the acoustic words but also the character sequences. This allows us to use our embeddings also for tasks involving comparisons between written and spoken words. For example, the standard task of spoken term detection (Fiscus et al., 2007) involves searching for examples of a given text query in spoken documents. This task is identical to queryby-example except that the query is given as text. In order to explore the potential of multi-view embeddings for such tasks, we design another proxy task, cross-view word discrimination. Here we are given a pair of inputs, one a written word and one an acoustic word segment, and our task is to determine if the acoustic signal is an example of the written word. The evalution proceeds analogously to the acoustic word discrimination task: We output “yes” if the cosine distance between the embeddings of the written and spoken sequences are below some threshold, and measure performance as the average precision (AP) over all thresholds.
+
+Finally, we also would like to obtain a more fine-grained measure of whether the learned embeddings capture our intuitive sense of similarity between words. Being able to capture word similarity may also be useful in building query or recognition systems that fail gracefully and produce humanlike errors. For this purpose we measure the rank correlation between embedding distances and character edit distances. This is analogous to the evaluation of semantic word embeddings via the rank correlation between embedding distances and human similarity judgments (Finkelstein et al., 2001; Hill et al., 2015). In our case, however, we do not use human judgments since the ground-truth edit distances themselves provide a good measure. We refer to this as the word similarity task, and we apply this measure to both pairs of acoustic embeddings and pairs of character sequence embeddings. Similar measures have been proposed by Ghannay et al. (2016) to evaluate acoustic word embeddings, although they considered only near neighbors of each word whereas we consider the correlation across the full range of word pairs.
+
+In the experiments described below, we first focus on the acoustic word discrimination task for purposes of initial exploration and hyperparameter search, and then largely fix the models for evaluation using the cross-view word discrimination and word similarity measures.
+
+# 4.1 DATA
+
+We use the same experimental setup and data as in Kamper et al. (2015, 2016); Settle & Livescu (2016). The task and setup were first developed by (Carlin et al., 2011). The data is drawn from the Switchboard English conversational speech corpus (Godfrey et al., 1992). The spoken word segments range in duration from 50 to 200 frames $0 . 5 \textrm { - } 2$ seconds). The train/dev/test splits contain 9971/10966/11024 pairs of acoustic segments and character sequences, corresponding to 1687/3918/3390 unique words. In computing the AP for the dev or test set, all pairs in the set are used, yielding approximately 60 million word pairs.
+
+The input to the embedding model in the acoustic view is a sequence of 39-dimensional vectors (one per frame) of standard mel frequency cepstral coefficients (MFCCs) and their first and second derivatives. The input to the character sequence embedding model is a sequence of 26-dimensional one-hot vectors indicating each character of the word’s orthography.
+
+# 4.2 MODEL DETAILS AND HYPERPARAMETER TUNING
+
+We experiment with different neural network architectures for each view, varying the number of stacked LSTM layers, the number of hidden units for each layer, and the use of single- or bidirectional LSTM cells. A coarse grid search shows that 2-layer bidirectional LSTMs with 512 hidden units per direction per layer perform well on the acoustic word discrimination task, and we keep this structure fixed for subsequent experiments (see Appendix A for more details). We use the outputs of the top-layer LSTMs as the learned embedding for each view, which is 1024-dimensional if bidirectional LSTMs are used.
+
+In training, we use dropout on the inputs of the acoustic view and between stacked layers for both views. The architecture is illustrated in Figure 1. For each training example, our contrastive losses require a corresponding negative example. We generate a negative character label sequence by uniformly sampling a word label from the training set that is different from the positive label. We perform a new negative label sampling at the beginning of each epoch. Similarly, negative acoustic feature sequences are uniformly sampled from all of the differently labeled acoustic feature sequences in the training set.
+
+The network weights are initialized with values sampled uniformly from the range $[ - 0 . 0 5 , 0 . 0 5 ]$ . We use the Adam optimizer (Kingma & Ba, 2015) for updating the weights using mini-batches of 20 acoustic segments, with an initial learning rate tuned over $\{ \mathrm { { 0 . 0 0 0 1 , \bar { 0 . 0 0 1 } } } \}$ . Dropout is used at each layer, with the rate tuned over $\{ 0 , 0 . 2 , 0 . 4 , 0 . 5 \}$ , in which 0.4 usually outperformed others. The margin in our basic contrastive objectives 0-3 is tuned over $\{ 0 . 3 , 0 . 4 , 0 . 5 , 0 . 6 , 0 . 7 \}$ , out of which 0.4 and 0.5 typically yield best results. For obj0 with the cost-sensitive margin, we tune the maximum margin $m _ { \mathrm { m a x } }$ over $\{ 0 . 5 , 0 . 6 , 0 . 7 \}$ and the threshold $t _ { \mathrm { m a x } }$ over $\{ 9 , 1 1 , 1 3 \}$ . We train each model for up to 1000 epochs. The model that gives the best AP on the development set is used for evaluation on the test set.
+
+# 4.3 EFFECTS OF DIFFERENT OBJECTIVES
+
+We presented four contrastive losses (3)–(6) and potential combinations in Section 2.1. We now explore the effects of these different objectives on the word discrimination tasks.
+
+Table 1 shows the development set AP for acoustic and cross-view word discrimination achieved using the various objectives. We tuned the objectives for the acoustic discrimination task, and then used the corresponding converged models for the cross-view task. Of the simple contrastive objectives, obj0 and $\mathrm { { \bar { \ o b j } } ^ { 2 } }$ (which involve only cross-view distances) slightly outperform the other two on the acoustic word discrimination task. The best-performing objective is the “symmetrized” objective $\mathrm { \ o b j ^ { 0 } + o b j ^ { 2 } }$ , which significantly outperforms all individual objectives (and the combination of the four). Finally, the cost-sensitive objective is very competitive as well, while falling slightly short of the best performance. We note that a similar objective to our ob $\mathrm { \hbar ^ { 6 } + o b j ^ { 2 } }$ was used by Vendrov et al. (2016) for the task of caption-image retrieval, where the authors essentially use all non-paired examples from the other view in the minibatch as negative examples (instead of random sampling one negative example as we do) to be contrasted with one paired example.
+
+![](images/04d3643ce9c112935d084f301ba1e540e182a27589bdeea428f56c642fe7c2c6.jpg)  
+Figure 2: Development set AP for several objectives on acoustic word discrimination.
+
+<table><tr><td>Objective</td><td>Dev AP (acoustic)</td><td>Dev AP (cross-view)</td></tr><tr><td></td><td></td><td></td></tr><tr><td>obj0</td><td>0.659</td><td>0.791</td></tr><tr><td>obj1</td><td>0.654</td><td>0.807</td></tr><tr><td>obj2</td><td>0.675</td><td>0.788</td></tr><tr><td>obj3</td><td>0.640</td><td>0.782</td></tr><tr><td>obj+ obj²</td><td>0.702</td><td>0.814</td></tr><tr><td>M obji</td><td>0.672</td><td>0.804</td></tr><tr><td>cost-sensitive</td><td>0.671</td><td>0.802</td></tr></table>
+
+Table 1: Word discrimination performance with different objectives.   
+Table 2: Final test set AP for different word discrimination approaches. The first line is a baseline using no word embeddings, but rather applying dynamic time warping (DTW) to the input MFCC features. The second and third lines are prior results using no word embeddings (but rather using DTW with learned correspondence autoencoder-based or phone posterior features, trained on larger external (in-domain) data). The remaining prior work corresponds to using cosine similarity between acoustic word embeddings.   
+
+<table><tr><td>Method</td><td>Test AP (acoustic)</td><td>Test AP (cross-view)</td></tr><tr><td>MFCCs + DTW (Kamper et al.,2016)</td><td>0.214</td><td></td></tr><tr><td>Correspondence autoencoder + DTW (Kamper et al., 2015)</td><td>0.469</td><td></td></tr><tr><td>Phone posteriors + DTW (Carlin et al., 2011)</td><td>0.497</td><td></td></tr><tr><td>Siamese CNN (Kamper et al., 2016)</td><td>0.549</td><td></td></tr><tr><td>Siamese LSTM (Settle &amp;Livescu, 2016)</td><td>0.671</td><td></td></tr><tr><td>Our multi-view LSTM obj° + obj²</td><td>0.806</td><td>0.892</td></tr></table>
+
+Figure 2 shows the progression of the development set AP for acoustic word discrimination over 1000 training epochs, using several of the objectives, where AP is evaluated every 5 epochs. We observe that even after 1000 epochs, the development set AP has not quite saturated, indicating that it may be possible to further improve performance.
+
+Overall, our best-performing objective is the combined ob $^ { 0 } + \mathrm { o b j } ^ { 2 }$ , and we use it for reporting final test-set results. Table 2 shows the test set AP for both the acoustic and cross-view tasks using our final model (“multi-view LSTM”). For comparison, we also include acoustic word discrimination results reported previously by Kamper et al. (2016); Settle & Livescu (2016). Previous approaches have not addressed the problem of learning embeddings jointly with the text view, so they can not be evaluated on the cross-view task.
+
+# 4.4 WORD SIMILARITY TASKS
+
+Table 3 gives our results on the word similarity tasks, that is the rank correlation (Spearman’s $\rho$ ) between embedding distances and orthographic edit distance (Levenshtein distance between character sequences). We measure this correlation for both our acoustic word embeddings and for our text embeddings. In the case of the text embeddings, we could of course directly measure the Levenshtein distance between the inputs; here we are simply measuring how much of this information the text embeddings are able to retain.
+
+Table 3: Word similarity results using fixed-margin and cost-sensitive objectives, given as rank correlation (Spearman’s $\rho$ ) between embedding distances and orthographic edit distances.   
+
+<table><tr><td>Objective</td><td>ρ (acoustic embedding)</td><td>）ρ (text embedding)</td></tr><tr><td>fixed-margin (objo)</td><td>0.179</td><td>0.207</td></tr><tr><td>cost-sensitive margin (objo)</td><td>0.240</td><td>0.270</td></tr></table>
+
+Interestingly, while the cost-sensitive objective did not produce substantial gains on the word discrimination tasks above, it does greatly improve the performance on this word similarity measure. This is a satisfying observation, since the cost-sensitive loss is trying to improve precisely this relationship between distances in the embedding space and the orthographic edit distance.
+
+Although we have trained our embeddings using orthographic labels, it is also interesting to consider how closely aligned the embeddings are with the corresponding phonetic pronunciations. For comparison, the rank correlation between our acoustic embeddings and phonetic edit distances is 0.226, and for our text embeddings it is 0.241, which are relatively close to the rank correlations with orthographic edit distance. A future direction is to directly train embeddings with phonetic sequence supervision rather than orthography; this setting involves somewhat stronger supervision, but it is easy to obtain in many cases.
+
+Another interesting point is that the performance is not a great deal better for the text embeddings than for the acoustic embeddings, even though the text embeddings have at their disposal the text input itself. We believe this has to do with the distribution of words in our data: While the data includes a large variety of words, it does not include many very similar pairs. In fact, of all possible pairs of unique training set words, fewer than $2 \%$ have an edit distance below 5 characters. Therefore, there may not be sufficient information to learn to distinguish detailed differences among character sequences, and the cost-sensitive loss ultimately does not learn much more than to separate different words. In future work it would be interesting to experiment with data sets that have a larger variety of similar words.
+
+# 4.5 VISUALIZATION OF LEARNED EMBEDDINGS
+
+Figure 3 gives a 2-dimensional t-SNE (van der Maaten & Hinton, 2008) visualization of selected acoustic and character sequences from the development set, including some that were seen in the training set and some previously unseen words. The previously seen words in this figure were selected uniformly at random among those that appear at least 15 times in the development set (the unseen words are the only six that appear at least 15 times in the development set). This visualization demonstrates that the acoustic embeddings cluster very tightly and are very close to the text embeddings, and that unseen words cluster nearly as well as previously seen ones.
+
+While Figure 3 shows the relationship among the multiple acoustic embeddings and the text embeddings, the words are all very different so we cannot draw conclusions about the relationships between words. Figure 4 provides another visualization, this time exploring the relationship among the text embeddings of a number of closely related words, namely all development set words ending in “-ly”, “-ing”, and “-tion”. This visualization confirms that related words are embedded close together, with the words sharing a suffix forming fairly well-defined clusters.
+
+# 5 CONCLUSION
+
+We have presented an approach for jointly learning acoustic word embeddings and their orthographic counterparts. This multi-view approach produces improved acoustic word embedding performance over previous approaches, and also has the benefit that the same embeddings can be applied for both spoken and written query tasks. We have explored a variety of contrastive objectives: ones with a fixed margin that aim to separate same and different word pairs, as well as a cost-sensitive loss that aims to capture orthographic edit distances. While the losses generally perform similarly for word discrimination tasks, the cost-sensitive loss improves the correlation between embedding distances and orthographic distances. One interesting direction for future work is to directly use knowledge about phonetic pronunciations, in both evaluation and training. Another direction is to extend our approach to directly train on both word and non-word segments.
+
+![](images/7c2f0d642050b64e900351eedc1ff0cfc1f14c96aa149fba6cc6e339a7d8ef0f.jpg)  
+Figure 3: Visualization via t-SNE of acoustic word embeddings (colored markers) and corresponding character sequence embeddings (text), for a set of development set words with at least 15 acoustic tokens. Words seen in training are in lower-case; unseen words are in upper-case.
+
+![](images/55e4866a47801c808bb2254e65ce6dee329cfb482f9799ded969933d263e1930.jpg)  
+Figure 4: Visualization via $\mathbf { t } { - } \mathbf { S N E }$ of character sequence embeddings for words with the suffixes “-ly” (blue), “-ing” (red), and “-tion” (green).
+
+# ACKNOWLEDGMENTS
+
+This research was supported by a Google Faculty Award and by NSF grant IIS-1321015. The opinions expressed in this work are those of the authors and do not necessarily reflect the views of the funding agency. This research used GPUs donated by NVIDIA Corporation. We thank Herman Kamper and Shane Settle for their assistance with the data and experimental setup.
+
+# REFERENCES
+
+Xavier Anguera, Luis Javier Rodriguez-Fuentes, Igor Szoke, Andi Buzo, and Florian Metze. Query ¨ by example search on speech at mediaeval 2014. In MediaEval, 2014.
+
+Kartik Audhkhasi, Andrew Rosenberg, Abhinav Sethy, Bhuvana Ramabhadran, and Brian Kingsbury. End-to-end ASR-free keyword search from speech. arXiv preprint arXiv:1701.04313, 2017.
+
+Samy Bengio and Georg Heigold. Word embeddings for speech recognition. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2014.
+
+Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic ´ language model. Journal of Machine Learing Research, 3(Feb):1137–1155, 2003.
+
+Jane Bromley, Isabelle Guyon, Yann Lecun, Eduard Sackinger, and Roopak Shah. Signature verifi- ¨ cation using a siamese time delay neural network. In Advances in Neural Information Processing Systems (NIPS), pp. 737–744, 1993.
+
+Michael A Carlin, Samuel Thomas, Aren Jansen, and Hynek Hermansky. Rapid evaluation of speech representations for spoken term discovery. In Proc. Interspeech, 2011.
+
+Guoguo Chen, Carolina Parada, and Tara N Sainath. Query-by-example keyword spotting using long short-term memory networks. In Proc. ICASSP, 2015.
+
+Sumit Chopra, Raia Hadsell, and Yann LeCun. Learning a similarity metric discriminatively, with application to face verification. In IEEE Computer Society Conf. Computer Vision and Pattern Recognition, pp. 539–546, 2005.
+
+Yu-An Chung, Chao-Chung Wu, Chia-Hao Shen, and Hung-Yi Lee. Unsupervised learning of audio segment representations using sequence-to-sequence recurrent neural networks. In Proc. Interspeech, 2016.
+
+Scott Deerwester, Susan T Dumais, George W Furnas, Thomas K Landauer, and Richard Harshman. Indexing by latent semantic analysis. Journal of the American society for information science, 41 (6):391, 1990.
+
+Lev Finkelstein, Evgeniy Gabrilovich, Yossi Matias, Ehud Rivlin, Zach Solan, Gadi Wolfman, and Eytan Ruppin. Placing search in context: The concept revisited. In Proceedings of the 10th international conference on World Wide Web, 2001.
+
+Jonathan G Fiscus, Jerome Ajot, John S Garofolo, and George Doddingtion. Results of the 2006 spoken term detection evaluation. In Proc. SIGIR, volume 7, pp. 51–57. Citeseer, 2007.
+
+Jort F Gemmeke, Tuomas Virtanen, and Antti Hurmalainen. Exemplar-based sparse representations for noise robust automatic speech recognition. IEEE Transactions on Acoustics, Speech, and Language Processing, 19(7):2067–2080, 2011.
+
+Sahar Ghannay, Yannick Esteve, Nathalie Camelin, and Paul Deleglise. Evaluation of acoustic word embeddings. In Proc. ACL Workshop on Evaluating Vector-Space Representations for NLP, 2016.
+
+John J Godfrey, Edward C Holliman, and Jane McDaniel. SWITCHBOARD: Telephone speech corpus for research and development. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 1992.
+
+Alex Graves, Abdel rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2013.
+
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In IEEE Computer Society Conf. Computer Vision and Pattern Recognition, 2006.
+
+David Harwath and James Glass. Deep multimodal semantic embeddings for speech and images. In Proc. IEEE Workshop on Automatic Speech Recognition and Understanding (ASRU), 2015.
+
+David Harwath and James R Glass. Learning word-like units from joint audio-visual analysis. arXiv preprint arXiv:1701.07481, 2017.
+
+David Harwath, Antonio Torralba, and James Glass. Unsupervised learning of spoken language with visual context. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Karl Moritz Hermann and Phil Blunsom. Multilingual distributed representations without word alignment. In Int. Conf. Learning Representations, 2014. arXiv:1312.6173 [cs.CL].
+
+Felix Hill, Roi Reichart, and Anna Korhonen. SimLex-999: Evaluating semantic models with (genuine) similarity estimation. Computational Linguistics, 41(4), 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8): 1735–1780, 1997.
+
+Baotian Hu, Zhengdong Lu, Hang Li, and Qingcai Chen. Convolutional neural network architectures for matching natural language sentences. In Advances in Neural Information Processing Systems (NIPS), 2014.
+
+Mohit Iyyer, Varun Manjunatha, Jordan Boyd-Graber, and Hal Daume III. Deep unordered com-´ position rivals syntactic methods for text classification. In Proc. Association for Computational Linguistics, 2015.
+
+Herman Kamper, Micah Elsner, Aren Jansen, and Sharon J. Goldwater. Unsupervised neural network based feature extraction using weak top-down constraints. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2015.
+
+Herman Kamper, Weiran Wang, and Karen Livescu. Deep convolutional acoustic word embeddings using word-pair side information. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2016.
+
+Diederik Kingma and Jimmy Ba. ADAM: A method for stochastic optimization. In Int. Conf. Learning Representations, 2015.
+
+Ryan Kiros, Yukun Zhu, Ruslan R Salakhutdinov, Richard Zemel, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Skip-thought vectors. In Advances in Neural Information Processing Systems (NIPS), 2015.
+
+Keith Levin, Katharine Henry, Aren Jansen, and Karen Livescu. Fixed-dimensional acoustic embeddings of variable-length segments in low-resource settings. In Proc. IEEE Workshop on Automatic Speech Recognition and Understanding (ASRU), 2013.
+
+Keith Levin, Aren Jansen, and Benjamin Van Durme. Segmental acoustic indexing for zero resource keyword search. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2015.
+
+Andrew L Maas, Stephen D Miller, Tyler M O’neil, Andrew $\mathrm { \Delta Y N g }$ , and Patrick Nguyen. Word-level acoustic modeling with convolutional vector regression. In Proc. ICML Workshop on Representation Learning, 2012.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems (NIPS), 2013.
+
+Andriy Mnih and Geoffrey Hinton. Three new graphical models for statistical language modelling. In ICML, 2007.
+
+Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Ng. Multimodal deep learning. In ICML, pp. 689–696, 2011.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global vectors for word representation. In Proc. Conference on Empirical Methods in Natural Language Processing, 2014.
+
+Shane Settle and Karen Livescu. Discriminative acoustic word embeddings: Recurrent neural network-based approaches. In Proc. IEEE Workshop on Spoken Language Technology (SLT), 2016.
+
+Richard Socher, Andrej Karpathy, Quoc V Le, Christopher D Manning, and Andrew Y Ng. Grounded compositional semantics for finding and describing images with sentences. Transactions of the Association for Computational Linguistics, 2:207–218, 2014.
+
+Kihyuk Sohn, Wenling Shang, and Honglak Lee. Improved multimodal deep learning with variation of information. In Advances in Neural Information Processing Systems (NIPS), pp. 2141–2149, 2014.
+
+Nitish Srivastava and Ruslan Salakhutdinov. Multimodal learning with deep boltzmann machines. Journal of Machine Learing Research, pp. 2949–2980, 2014.
+
+Gabriel Synnaeve, Thomas Schatz, and Emmanuel Dupoux. Phonetics embedding learning with side information. In Proc. IEEE Workshop on Spoken Language Technology (SLT), 2014.
+
+Laurens J. P. van der Maaten and Geoffrey E. Hinton. Visualizing data using $t$ -SNE. Journal of Machine Learing Research, 9:2579–2605, November 2008.
+
+Ivan Vendrov, Ryan Kiros, Sanja Fidler, and Raquel Urtasun. Order-embeddings of images and language. In Int. Conf. Learning Representations, 2016.
+
+Weiran Wang, Raman Arora, Karen Livescu, and Jeff Bilmes. On deep multi-view representation learning. In ICML, pp. 1083–1092, 2015.
+
+John Wieting, Mohit Bansal, Kevin Gimpel, and Karen Livescu. Towards universal paraphrastic sentence embeddings. In Int. Conf. Learning Representations, 2016.
+
+# A ADDITIONAL ANALYSIS
+
+We first explore the effect of network architectures for our embedding models. We learn embeddings using objective obj0 and evaluate them on the acoustic and cross-view word discrimination tasks. The resulting average precisions on the development set are given in Table 4. All of the models were trained for 1000 epochs, except for the 1-layer unidirectional models which converged after 500 epochs. It is clear that bidirectional LSTMs are more successful than unidirectional LSTMs for these tasks, and two layers of LSTMs are much better than a single layer of LSTMs. We did not observe significant further improvement by using more than two layers of LSTMs. For all other experiments, we fix the architecture to 2-layer bidirectional LSTMs for each view.
+
+Dev AP Dev AP (acoustic word discrimination) (cross-view word discrimination)   
+
+<table><tr><td>1-layer unidirectional</td><td>0.379</td><td>0.616</td></tr><tr><td>1-layer bidirectional</td><td>0.466</td><td>0.690</td></tr><tr><td>2-layer bidirectional</td><td>0.659</td><td>0.791</td></tr></table>
+
+Table 4: Average precision (AP) for acoustic and cross-view word discrimination tasks on the development set, using embeddings learned with objective obj0 and different LSTM architectures.
+
+![](images/0618f23038e66a0aa68d56348d9bef2abac0f6d0be9848722320fd08dc601a54.jpg)  
+Figure 5: Precision-recall curve (left: two-layer bidirectional LSTM trained with $\mathrm { \ o b j ^ { 0 } + o b j ^ { 2 } }$ for word discrimination task) and scatter plot of embedding distances vs. orthographic distances (right: cost-sensitive margin model for word similarity task), for our best embedding models.
+
+In Figure 5 we also give the precision-recall curve for our best models, as well as the scatter plot of cosine distances between acoustic embeddings vs. orthographic edit distances.

parse/train/rJxDkvqee/rJxDkvqee_content_list.json

@@ -0,0 +1,1510 @@
+[
+    {
+        "type": "text",
+        "text": "MULTI-VIEW RECURRENT NEURALACOUSTIC WORD EMBEDDINGS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            674,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wanjia He ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            171,
+            259,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science University of Chicago Chicago, IL 60637, USA wanjia@ttic.edu ",
+        "bbox": [
+            184,
+            185,
+            405,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Weiran Wang & Karen Livescu Toyota Technological Institute at Chicago Chicago, IL 60637, USA {weiranwang,klivescu}@ttic.edu ",
+        "bbox": [
+            472,
+            170,
+            763,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work has begun exploring neural acoustic word embeddings—fixeddimensional vector representations of arbitrary-length speech segments corresponding to words. Such embeddings are applicable to speech retrieval and recognition tasks, where reasoning about whole words may make it possible to avoid ambiguous sub-word representations. The main idea is to map acoustic sequences to fixed-dimensional vectors such that examples of the same word are mapped to similar vectors, while different-word examples are mapped to very different vectors. In this work we take a multi-view approach to learning acoustic word embeddings, in which we jointly learn to embed acoustic sequences and their corresponding character sequences. We use deep bidirectional LSTM embedding models and multi-view contrastive losses. We study the effect of different loss variants, including fixed-margin and cost-sensitive losses. Our acoustic word embeddings improve over previous approaches for the task of word discrimination. We also present results on other tasks that are enabled by the multi-view approach, including cross-view word discrimination and word similarity. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            516
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            544,
+            334,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Word embeddings—continuous-valued vector representations of words—are an almost ubiquitous component of recent natural language processing (NLP) research. Word embeddings can be learned using spectral methods (Deerwester et al., 1990) or, more commonly in recent work, via neural networks (Bengio et al., 2003; Mnih & Hinton, 2007; Mikolov et al., 2013; Pennington et al., 2014). Word embeddings can also be composed to form embeddings of phrases, sentences, or documents (Socher et al., 2014; Kiros et al., 2015; Wieting et al., 2016; Iyyer et al., 2015). ",
+        "bbox": [
+            174,
+            575,
+            825,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In typical NLP applications, such embeddings are intended to represent the semantics of the corresponding words/sequences. In contrast, embeddings that represent the way a word or sequence sounds are rarely considered. In this work we address this problem, starting with embeddings of individual words. Such embeddings could be useful for tasks like spoken term detection (Fiscus et al., 2007), spoken query-by-example search (Anguera et al., 2014), or even speech recognition using a whole-word approach (Gemmeke et al., 2011; Bengio & Heigold, 2014). In tasks that involve comparing speech segments to each other, vector embeddings can allow more efficient and more accurate distance computation than sequence-based approaches such as dynamic time warping (Levin et al., 2013, 2015; Kamper et al., 2016; Settle & Livescu, 2016; Chung et al., 2016). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of learning vector representations of acoustic sequences and orthographic (character) sequences corresponding to single words, such that the learned embeddings represent the way the word sounds. We take a multi-view approach, where we jointly learn the embeddings for character and acoustic sequences. We consider several contrastive losses, based on learning from pairs of matched acoustic-orthographic examples and randomly drawn mismatched pairs. The losses correspond to different goals for learning such embeddings; for example, we might want the embeddings of two waveforms to be close when they correspond to the same word and far when they correspond to different ones, or we might want the distances between embeddings to correspond to some ground-truth orthographic edit distance. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the useful properties of this multi-view approach is that, unlike earlier work on acoustic word embeddings, it produces both acoustic and orthographic embeddings that can be directly compared. This makes it possible to use the same learned embeddings for multiple single-view and cross-view tasks. Our multi-view embeddings produce improved results over earlier work on acoustic word discrimination, as well as encouraging results on cross-view discrimination and word similarity.1 ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 OUR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            339,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first introduce our approach for learning acoustic word embeddings in a multiview setting, after briefly reviewing related approaches to put ours in context. We then discuss the particular neural network architecture we use, based on bidirectional long short-term memory (LSTM) networks (Hochreiter & Schmidhuber, 1997). ",
+        "bbox": [
+            173,
+            222,
+            825,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MULTI-VIEW LEARNING OF ACOUSTIC WORD EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            296,
+            624,
+            309
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Previous approaches have focused on learning acoustic word embeddings in a “single-view” setting. In the simplest approach, one uses supervision of the form “acoustic segment $\\mathbf { x }$ is an instance of the word dataset oing optim $\\mathbf { y } ^ { \\mathsf { , , } \\mathsf { , } }$ , and trains the embedding to be discriired acoustic segments and word labels tion: word identity. Formally, given a, this approach solves the follow$\\{ ( \\mathbf { x } _ { i } , \\mathbf { y } _ { i } ) \\} _ { i = 1 } ^ { N }$ ",
+        "bbox": [
+            173,
+            316,
+            825,
+            386
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4836f082a95967dec5f14aff1c4753b04d30bc7876fb07da8ff9e1acd0590ef.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { f , h } { \\mathrm { \\ o b j } _ { c l a s s i f y } } : = \\frac { 1 } { N } \\sum _ { i } ^ { N } \\ell \\left( h ( f ( \\mathbf { x } _ { i } ) ) , \\mathbf { y } _ { i } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            381,
+            647,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where network $f$ maps an acoustic segment into a fixed-dimensional feature vector/embedding, $h$ is a classifier that predicts the corresponding word label from the label set of the training data, and the loss $\\ell$ measures the discrepancy between the prediction and ground-truth word label (one can use any multi-class classification loss here, and a typical choice is the cross-entropy loss where $h$ has a softmax top layer). The two networks $f$ and $h$ are trained jointly. Equivalently, one could consider the composition $h ( f ( \\mathbf { x } ) )$ as a classifier network, and use any intermediate layer’s activations as the features. We refer to the objective in (1) as the “classifier network” objective, which has been used in several prior studies on acoustic word embeddings (Bengio & Heigold, 2014; Kamper et al., 2016; Settle & Livescu, 2016). ",
+        "bbox": [
+            173,
+            424,
+            825,
+            551
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This objective, however, is not ideal for learning acoustic word embeddings. This is because the set of possible word labels is huge, and we may not have enough instances of each label to train a good classifier. In downstream tasks, we may encounter acoustic segments of words that did not appear in the embedding training set, and it is not clear that the classifier-based embeddings will have reasonable behavior on previously unseen words. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An alternative approach, based on Siamese networks (Bromley et al., 1993), uses supervision of the form “segment $\\mathbf { \\dot { x } } ^ { \\hat { 1 } }$ is similar to segment $\\mathbf { x } ^ { 2 }$ , and is not similar to segment $\\mathbf { x } ^ { 3 } \\mathbf { \\ ' }$ ”, where two segments are considered similar if they have the same word label and dissimilar otherwise. Models based on Siamese networks have been used for a variety of representation learning problems in NLP $\\mathrm { H u }$ et al., 2014; Wieting et al., 2016), vision (Hadsell et al., 2006), and speech (Synnaeve et al., 2014; Kamper et al., 2015) including acoustic word embeddings (Kamper et al., 2016; Settle & Livescu, 2016). A typical objective in this category enforces that the distance between $( \\mathbf { x } ^ { 1 } , \\mathbf { x } ^ { 3 } )$ is larger than the distance between $( \\mathbf { x } ^ { 1 } , \\mathbf { x } ^ { 2 } )$ by some margin: ",
+        "bbox": [
+            173,
+            633,
+            825,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/548c74ed2065562251283f8a57c2571af9513be60bce4215a55281d78aa0c2bb.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { f } \\ \\mathrm { o b j } _ { s i a m e s e } : = \\frac { 1 } { N } \\sum _ { i } ^ { N } \\operatorname* { m a x } \\left( 0 , \\ m + d i s \\left( f ( \\mathbf { x } _ { i } ^ { 1 } ) , \\ f ( \\mathbf { x } _ { i } ^ { 2 } ) \\right) - d i s \\left( f ( \\mathbf { x } _ { i } ^ { 1 } ) , \\ f ( \\mathbf { x } _ { i } ^ { 3 } ) \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            748,
+            782,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the network $f$ extracts the fixed-dimensional embedding, the distance function $d i s \\left( \\cdot , \\cdot \\right)$ measures the distance between the two embedding vectors, and $m > 0$ is the margin parameter. The term “Siamese” (Bromley et al., 1993; Chopra et al., 2005) refers to the fact that the triplet $( \\mathbf { x } ^ { 1 } , \\mathbf { x } ^ { 2 } , \\mathbf { x } ^ { 3 } )$ share the same embedding network $f$ . ",
+        "bbox": [
+            173,
+            795,
+            825,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unlike the classification-based loss, the Siamese network loss does not enforce hard decisions on the label of each segment. Instead it tries to learn embeddings that respect distances between word pairs, which can be helpful for dealing with unseen words. The Siamese network approach also uses more examples in training, as one can easily generate many more triplets than (segment, label) pairs, and it is not limited to those labels that occur a sufficient number of times in the training set. ",
+        "bbox": [
+            176,
+            857,
+            821,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The above approaches treat the word labels as discrete classes, which ignores the similarity between different words, and does not take advantage of the more complex information contained in the character sequences corresponding to word labels. The orthography naturally reflects some aspects of similarity between the words’ pronunciations, which should also be reflected in the acoustic embeddings. One way to learn features from multiple sources of complementary information is using a multi-view representation learning setting. We take this approach, and consider the acoustic segment and the character sequence to be two different views of the pronunciation of the word. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While many deep multi-view learning objectives are applicable (Ngiam et al., 2011; Srivastava & Salakhutdinov, 2014; Sohn et al., 2014; Wang et al., 2015), we consider the multi-view contrastive loss objective of (Hermann & Blunsom, 2014), which is simple to optimize and implement and performs well in practice. In this algorithm, we embed acoustic segments $\\mathbf { x }$ by a network $f$ and character label sequences c by another network $g$ into a common space, and use weak supervision of the form “for paired segment $\\mathbf { x } ^ { + }$ and its character label sequence $\\mathbf { c } ^ { + }$ , the distance between their embedding is much smaller than the distance between embeddings of $\\mathbf { x } ^ { + }$ and an unmatched character label sequence $\\mathbf { c } ^ { - , }$ ”. Formally, we optimize the following objective with such supervision: ",
+        "bbox": [
+            174,
+            256,
+            825,
+            369
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22132e0e24074064aa19553891d2d5a1436d56819220d137bd9404c296263059.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { f , g } \\mathrm { ~ o b j } ^ { 0 } : = \\frac { 1 } { N } \\sum _ { i } ^ { N } \\operatorname* { m a x } \\left( 0 , m + d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , g ( \\mathbf { c } _ { i } ^ { + } ) \\right) - d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , g ( \\mathbf { c } _ { i } ^ { - } ) \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            368,
+            766,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { c } _ { i } ^ { - }$ is a negative character label sequence of $\\mathbf { x } _ { i } ^ { + }$ to be contrasted with the positive/correct character sequence ${ \\mathbf { c } } _ { i } ^ { + }$ , and $m$ is the margin parameter. In this paper we use the cosine distance, $\\begin{array} { r } { d i s \\left( \\mathbf { a } , \\mathbf { b } \\right) = 1 - \\bigg \\langle \\frac { \\mathbf { a } } { \\left\\| \\mathbf { a } \\right\\| } , \\ \\frac { \\mathbf { b } } { \\left\\| \\mathbf { b } \\right\\| } \\bigg \\rangle . ^ { 2 } } \\end{array}$ ",
+        "bbox": [
+            173,
+            411,
+            825,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that in the multi-view setting, we have multiple ways of generating triplets that contain one positive pair and one negative pair each. Below are the other three objectives we explore in this paper: ",
+        "bbox": [
+            174,
+            472,
+            825,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/baf87c0ce0ed6bbb2af8cae8c2106f1c012d1c53b27fcb5334d9b3256a0b7c54.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { \\underset { f , g } { \\operatorname* { m i n } \\mathrm { ~ o b j } } ^ { 1 } : = \\frac { 1 } { N } \\sum _ { i } ^ { N } \\operatorname* { m a x } \\left( 0 , m + d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , g ( \\mathbf { c } _ { i } ^ { + } ) \\right) - d i s \\left( g ( \\mathbf { c } _ { i } ^ { + } ) , g ( \\mathbf { c } _ { i } ^ { - } ) \\right) \\right) , } & \\\\ & { \\underset { f , g } { \\operatorname* { m i n } \\mathrm { ~ o b j } } ^ { 2 } : = \\frac { 1 } { N } \\sum _ { i } ^ { N } \\operatorname* { m a x } \\left( 0 , m + d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , g ( \\mathbf { c } _ { i } ^ { + } ) \\right) - d i s \\left( f ( \\mathbf { x } _ { i } ^ { - } ) , g ( \\mathbf { c } _ { i } ^ { + } ) \\right) \\right) , } & \\\\ & { \\underset { f , g } { \\operatorname* { m i n } \\mathrm { ~ o b j } } ^ { 3 } : = \\frac { 1 } { N } \\sum _ { i } ^ { N } \\operatorname* { m a x } \\left( 0 , m + d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , g ( \\mathbf { c } _ { i } ^ { + } ) \\right) - d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , f ( \\mathbf { x } _ { i } ^ { - } ) \\right) \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            513,
+            766,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { x } _ { i } ^ { - }$ in (5) and (6) refers to a negative acoustic feature sequence, that is one with a different label from ${ \\bf x } _ { i } ^ { + }$ . We note that $\\mathrm { \\ o b j } ^ { \\mathrm { 1 } }$ and $\\mathrm { o b j } ^ { 3 }$ contain distances between same-view embeddings, and are less thoroughly explored in the literature. We will also consider combinations of obj0 through obj3. ",
+        "bbox": [
+            176,
+            646,
+            823,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, thus far we have considered losses that do not explicitly take into account the degree of difference between the positive and negative pairs (although the learned embeddings may implicitly learn this through the relationship between sequences in the two views). We also consider a costsensitive objective designed to explicitly arrange the embedding space such that word similarity is respected. In (3), instead of a fixed margin $m$ , we use: ",
+        "bbox": [
+            173,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a4e048e013341867f7c667fe9a1d9ff774b96cf587689614a216cb44340d3a3.jpg",
+        "text": "$$\nm ( { \\bf c } ^ { + } , { \\bf c } ^ { - } ) : = m _ { \\mathrm { m a x } } \\cdot \\frac { \\mathrm { m i n } \\left( t _ { \\mathrm { m a x } } , e d i t d i s ( { \\bf c } ^ { + } , { \\bf c } ^ { - } ) \\right) } { t _ { \\mathrm { m a x } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            770,
+            678,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $t _ { \\mathrm { m a x } } > 0$ is a threshold for edit distances (all edit distances above $t _ { \\mathrm { m a x } }$ are considered equally bad), and $m _ { m a x }$ is the maximum margin we impose. The margin is set to $m _ { m a x }$ if the edit distance between two character sequences is above $t _ { \\mathrm { m a x } }$ ; otherwise it scales linearly with the edit distance $e d i t d i s ( { \\bf c } ^ { + } , { \\bf c } ^ { - } ) )$ . We use the Levenshtein distance as the edit distance. Here we explore the costsensitive margin with $\\mathrm { o b j } ^ { \\mathrm { 0 } }$ , but it could in principle be used with other objectives as well. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3ff837397d39b835e1fc3d63562ed43f1f1a643589586c9893411912a989b7d.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of our embedding architecture and contrastive multi-view approach. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            821,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 RECURRENT NEURAL NETWORK ARCHITECTURE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            311,
+            558,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the inputs of both views have a sequential structure, we implement both $f$ and $g$ with recurrent neural networks and in particular long-short term memory networks (LSTMs). Recurrent neural networks are the state-of-the-art models for a number of speech tasks including speech recognition Graves et al. (2013), and LSTM-based acoustic word embeddings have produced the best results on one of the tasks in our experiments (Settle & Livescu, 2016). ",
+        "bbox": [
+            174,
+            333,
+            823,
+            402
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 1, our $f$ and $g$ are produced by multi-layer (stacked) bidirectional LSTMs. The inputs can be any frame-level acoustic feature representation and vector representation of the characters in the orthographic input. At each layer, two LSTM cells process the input sequence from left to right and from right to left respectively. At intermediate layers, the outputs of the two LSTMs at each time step are concatenated to form the input sequence to the next layer. At the top layer, the last time step outputs of the two LSTMs are concatenated to form a fixed-dimensional embedding of the view, and the embeddings are then used to calculate the cosine distances in our objectives. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            341,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We are aware of no prior work on multi-view learning of acoustic and character-based word embeddings. However, acoustic word embeddings learned in other ways have recently begun to be studied. Levin et al. (2013) proposed an approach for embedding an arbitrary-length segment of speech as a fixed-dimensional vector, based on representing each word as a vector of dynamic time warping (DTW) distances to a set of template words. This approach produced improved performance on a word discrimination task compared to using raw DTW distances, and was later also applied successfully for a query-by-example task (Levin et al., 2015). One disadvantage of this approach is that, while DTW handles the issue of variable sequence lengths, it is computationally costly and involves a number of DTW parameters that are not learned. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Kamper et al. (2016) and Settle & Livescu (2016) later improved on Levin et al.’s word discrimination results using convolutional neural networks (CNNs) and recurrent neural networks (RNNs) trained with either a classification or contrastive loss. Bengio & Heigold (2014) trained convolutional neural network (CNN)-based acoustic word embeddings for rescoring the outputs of a speech recognizer, using a loss combining classification and ranking criteria. Maas et al. (2012) trained a CNN to predict a semantic word embedding from an acoustic segment, and used the resulting embeddings as features in a segmental word-level speech recognizer. Harwath and Glass Harwath & Glass (2015); Harwath et al. (2016); Harwath & Glass (2017) jointly trained CNN embeddings of images and spoken captions, and showed that word-like unit embeddings can be extracted from the speech model. CNNs require normalizing the duration of the input sequences, which has typically been done via padding. RNNs, on the other hand, are more flexible in dealing with very different-length sequences. Chen et al. (2015) used long short-term memory (LSTM) networks with a classification loss to embed acoustic words for a simple (single-query) query-by-example search task. Chung et al. (2016) learned acoustic word embeddings based on recurrent neural network (RNN) autoencoders, and found that they improve over DTW for a word discrimination task similar to that of Levin et al. (2013). Audhkhasi et al. (2017) learned autoencoders for acoustic and written words, as well as a model for comparing the two, and applied these to a keyword search task. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Evaluation of acoustic word embeddings in downstream tasks such as speech recognition and search can be costly, and can obscure details of embedding models and training approaches. Most evaluations have been based on word discrimination – the task of determining whether two speech segments correspond to the same word or not – which can be seen as a proxy for query-by-example search (Levin et al., 2013; Kamper et al., 2016; Settle & Livescu, 2016; Chung et al., 2016). One difference between word discrimination and search/recognition tasks is that in word discrimination the word boundaries are given. However, prior work has been able to apply results from word discrimination Levin et al. (2013) to improve a query-by-example system without known word boundaries Levin et al. (2015), by simply applying their embeddings to non-word segments as well. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The only prior work focused on vector embeddings of character sequences explicitly aimed at representing their acoustic similarity is that of Ghannay et al. (2016), who proposed evaluations based on nearest-neighbor retrieval, phonetic/orthographic similarity measures, and homophone disambiguation. We use related tasks here, as well as acoustic word discrimination for comparison with prior work on acoustic embeddings. ",
+        "bbox": [
+            174,
+            236,
+            823,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            348,
+            446,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ultimate goal is to gain improvements in speech systems where word-level discrimination is needed, such as speech recognition and query-by-example search. However, in order to focus on the content of the embeddings themselves and to more quickly compare a variety of models, it is desirable to have surrogate tasks that serve as intrinsic measures of performance. Here we consider three forms of evaluation, all based on measuring whether cosine distances between learned embeddings correspond well to desired properties. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the first task, acoustic word discrimination, we are given a pair of acoustic sequences and must decide whether they correspond to the same word or to different words. This task has been used in several prior papers on acoustic word embeddings Kamper et al. (2015, 2016); Chung et al. (2016); Settle & Livescu (2016) and is a proxy for query-by-example search. For each given spoken word pair, we calculate the cosine distance between their embeddings. If the cosine distance is below a threshold, we output “yes” (same word), otherwise we output “no” (different words). The performance measure is the average precision (AP), which is the area under the precision-recall curve generated by varying the threshold and has a maximum value of 1. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our multi-view setup, we embed not only the acoustic words but also the character sequences. This allows us to use our embeddings also for tasks involving comparisons between written and spoken words. For example, the standard task of spoken term detection (Fiscus et al., 2007) involves searching for examples of a given text query in spoken documents. This task is identical to queryby-example except that the query is given as text. In order to explore the potential of multi-view embeddings for such tasks, we design another proxy task, cross-view word discrimination. Here we are given a pair of inputs, one a written word and one an acoustic word segment, and our task is to determine if the acoustic signal is an example of the written word. The evalution proceeds analogously to the acoustic word discrimination task: We output “yes” if the cosine distance between the embeddings of the written and spoken sequences are below some threshold, and measure performance as the average precision (AP) over all thresholds. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, we also would like to obtain a more fine-grained measure of whether the learned embeddings capture our intuitive sense of similarity between words. Being able to capture word similarity may also be useful in building query or recognition systems that fail gracefully and produce humanlike errors. For this purpose we measure the rank correlation between embedding distances and character edit distances. This is analogous to the evaluation of semantic word embeddings via the rank correlation between embedding distances and human similarity judgments (Finkelstein et al., 2001; Hill et al., 2015). In our case, however, we do not use human judgments since the ground-truth edit distances themselves provide a good measure. We refer to this as the word similarity task, and we apply this measure to both pairs of acoustic embeddings and pairs of character sequence embeddings. Similar measures have been proposed by Ghannay et al. (2016) to evaluate acoustic word embeddings, although they considered only near neighbors of each word whereas we consider the correlation across the full range of word pairs. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the experiments described below, we first focus on the acoustic word discrimination task for purposes of initial exploration and hyperparameter search, and then largely fix the models for evaluation using the cross-view word discrimination and word similarity measures. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            161,
+            253,
+            176
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use the same experimental setup and data as in Kamper et al. (2015, 2016); Settle & Livescu (2016). The task and setup were first developed by (Carlin et al., 2011). The data is drawn from the Switchboard English conversational speech corpus (Godfrey et al., 1992). The spoken word segments range in duration from 50 to 200 frames $0 . 5 \\textrm { - } 2$ seconds). The train/dev/test splits contain 9971/10966/11024 pairs of acoustic segments and character sequences, corresponding to 1687/3918/3390 unique words. In computing the AP for the dev or test set, all pairs in the set are used, yielding approximately 60 million word pairs. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            282
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The input to the embedding model in the acoustic view is a sequence of 39-dimensional vectors (one per frame) of standard mel frequency cepstral coefficients (MFCCs) and their first and second derivatives. The input to the character sequence embedding model is a sequence of 26-dimensional one-hot vectors indicating each character of the word’s orthography. ",
+        "bbox": [
+            174,
+            289,
+            825,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 MODEL DETAILS AND HYPERPARAMETER TUNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            362,
+            560,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We experiment with different neural network architectures for each view, varying the number of stacked LSTM layers, the number of hidden units for each layer, and the use of single- or bidirectional LSTM cells. A coarse grid search shows that 2-layer bidirectional LSTMs with 512 hidden units per direction per layer perform well on the acoustic word discrimination task, and we keep this structure fixed for subsequent experiments (see Appendix A for more details). We use the outputs of the top-layer LSTMs as the learned embedding for each view, which is 1024-dimensional if bidirectional LSTMs are used. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            481
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In training, we use dropout on the inputs of the acoustic view and between stacked layers for both views. The architecture is illustrated in Figure 1. For each training example, our contrastive losses require a corresponding negative example. We generate a negative character label sequence by uniformly sampling a word label from the training set that is different from the positive label. We perform a new negative label sampling at the beginning of each epoch. Similarly, negative acoustic feature sequences are uniformly sampled from all of the differently labeled acoustic feature sequences in the training set. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            585
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The network weights are initialized with values sampled uniformly from the range $[ - 0 . 0 5 , 0 . 0 5 ]$ . We use the Adam optimizer (Kingma & Ba, 2015) for updating the weights using mini-batches of 20 acoustic segments, with an initial learning rate tuned over $\\{ \\mathrm { { 0 . 0 0 0 1 , \\bar { 0 . 0 0 1 } } } \\}$ . Dropout is used at each layer, with the rate tuned over $\\{ 0 , 0 . 2 , 0 . 4 , 0 . 5 \\}$ , in which 0.4 usually outperformed others. The margin in our basic contrastive objectives 0-3 is tuned over $\\{ 0 . 3 , 0 . 4 , 0 . 5 , 0 . 6 , 0 . 7 \\}$ , out of which 0.4 and 0.5 typically yield best results. For obj0 with the cost-sensitive margin, we tune the maximum margin $m _ { \\mathrm { m a x } }$ over $\\{ 0 . 5 , 0 . 6 , 0 . 7 \\}$ and the threshold $t _ { \\mathrm { m a x } }$ over $\\{ 9 , 1 1 , 1 3 \\}$ . We train each model for up to 1000 epochs. The model that gives the best AP on the development set is used for evaluation on the test set. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECTS OF DIFFERENT OBJECTIVES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            736,
+            467,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We presented four contrastive losses (3)–(6) and potential combinations in Section 2.1. We now explore the effects of these different objectives on the word discrimination tasks. ",
+        "bbox": [
+            174,
+            758,
+            821,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the development set AP for acoustic and cross-view word discrimination achieved using the various objectives. We tuned the objectives for the acoustic discrimination task, and then used the corresponding converged models for the cross-view task. Of the simple contrastive objectives, obj0 and $\\mathrm { { \\bar { \\ o b j } } ^ { 2 } }$ (which involve only cross-view distances) slightly outperform the other two on the acoustic word discrimination task. The best-performing objective is the “symmetrized” objective $\\mathrm { \\ o b j ^ { 0 } + o b j ^ { 2 } }$ , which significantly outperforms all individual objectives (and the combination of the four). Finally, the cost-sensitive objective is very competitive as well, while falling slightly short of the best performance. We note that a similar objective to our ob $\\mathrm { \\hbar ^ { 6 } + o b j ^ { 2 } }$ was used by Vendrov et al. (2016) for the task of caption-image retrieval, where the authors essentially use all non-paired examples from the other view in the minibatch as negative examples (instead of random sampling one negative example as we do) to be contrasted with one paired example. ",
+        "bbox": [
+            173,
+            794,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/04d3643ce9c112935d084f301ba1e540e182a27589bdeea428f56c642fe7c2c6.jpg",
+        "image_caption": [
+            "Figure 2: Development set AP for several objectives on acoustic word discrimination. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            116,
+            475,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a66f2c5374cf38e0a90641c58171464fad1c20ee2c89838be0211c88155c9f88.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Objective</td><td>Dev AP (acoustic)</td><td>Dev AP (cross-view)</td></tr><tr><td></td><td></td><td></td></tr><tr><td>obj0</td><td>0.659</td><td>0.791</td></tr><tr><td>obj1</td><td>0.654</td><td>0.807</td></tr><tr><td>obj2</td><td>0.675</td><td>0.788</td></tr><tr><td>obj3</td><td>0.640</td><td>0.782</td></tr><tr><td>obj+ obj²</td><td>0.702</td><td>0.814</td></tr><tr><td>M obji</td><td>0.672</td><td>0.804</td></tr><tr><td>cost-sensitive</td><td>0.671</td><td>0.802</td></tr></table>",
+        "bbox": [
+            514,
+            122,
+            810,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/51a8ebbed09494b63949ba840417c62341c9d01a89c654e053f5e29208a502a0.jpg",
+        "table_caption": [
+            "Table 1: Word discrimination performance with different objectives. ",
+            "Table 2: Final test set AP for different word discrimination approaches. The first line is a baseline using no word embeddings, but rather applying dynamic time warping (DTW) to the input MFCC features. The second and third lines are prior results using no word embeddings (but rather using DTW with learned correspondence autoencoder-based or phone posterior features, trained on larger external (in-domain) data). The remaining prior work corresponds to using cosine similarity between acoustic word embeddings. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Test AP (acoustic)</td><td>Test AP (cross-view)</td></tr><tr><td>MFCCs + DTW (Kamper et al.,2016)</td><td>0.214</td><td></td></tr><tr><td>Correspondence autoencoder + DTW (Kamper et al., 2015)</td><td>0.469</td><td></td></tr><tr><td>Phone posteriors + DTW (Carlin et al., 2011)</td><td>0.497</td><td></td></tr><tr><td>Siamese CNN (Kamper et al., 2016)</td><td>0.549</td><td></td></tr><tr><td>Siamese LSTM (Settle &amp;Livescu, 2016)</td><td>0.671</td><td></td></tr><tr><td>Our multi-view LSTM obj° + obj²</td><td>0.806</td><td>0.892</td></tr></table>",
+        "bbox": [
+            200,
+            353,
+            795,
+            470
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            613,
+            823,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the progression of the development set AP for acoustic word discrimination over 1000 training epochs, using several of the objectives, where AP is evaluated every 5 epochs. We observe that even after 1000 epochs, the development set AP has not quite saturated, indicating that it may be possible to further improve performance. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Overall, our best-performing objective is the combined ob $^ { 0 } + \\mathrm { o b j } ^ { 2 }$ , and we use it for reporting final test-set results. Table 2 shows the test set AP for both the acoustic and cross-view tasks using our final model (“multi-view LSTM”). For comparison, we also include acoustic word discrimination results reported previously by Kamper et al. (2016); Settle & Livescu (2016). Previous approaches have not addressed the problem of learning embeddings jointly with the text view, so they can not be evaluated on the cross-view task. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 WORD SIMILARITY TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            397,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3 gives our results on the word similarity tasks, that is the rank correlation (Spearman’s $\\rho$ ) between embedding distances and orthographic edit distance (Levenshtein distance between character sequences). We measure this correlation for both our acoustic word embeddings and for our text embeddings. In the case of the text embeddings, we could of course directly measure the Levenshtein distance between the inputs; here we are simply measuring how much of this information the text embeddings are able to retain. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/130dbdea3e8a61711c846796eadd9b3cef0735398a906d2054084fa95ff9ce52.jpg",
+        "table_caption": [
+            "Table 3: Word similarity results using fixed-margin and cost-sensitive objectives, given as rank correlation (Spearman’s $\\rho$ ) between embedding distances and orthographic edit distances. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Objective</td><td>ρ (acoustic embedding)</td><td>）ρ (text embedding)</td></tr><tr><td>fixed-margin (objo)</td><td>0.179</td><td>0.207</td></tr><tr><td>cost-sensitive margin (objo)</td><td>0.240</td><td>0.270</td></tr></table>",
+        "bbox": [
+            228,
+            99,
+            764,
+            150
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, while the cost-sensitive objective did not produce substantial gains on the word discrimination tasks above, it does greatly improve the performance on this word similarity measure. This is a satisfying observation, since the cost-sensitive loss is trying to improve precisely this relationship between distances in the embedding space and the orthographic edit distance. ",
+        "bbox": [
+            174,
+            214,
+            825,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Although we have trained our embeddings using orthographic labels, it is also interesting to consider how closely aligned the embeddings are with the corresponding phonetic pronunciations. For comparison, the rank correlation between our acoustic embeddings and phonetic edit distances is 0.226, and for our text embeddings it is 0.241, which are relatively close to the rank correlations with orthographic edit distance. A future direction is to directly train embeddings with phonetic sequence supervision rather than orthography; this setting involves somewhat stronger supervision, but it is easy to obtain in many cases. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another interesting point is that the performance is not a great deal better for the text embeddings than for the acoustic embeddings, even though the text embeddings have at their disposal the text input itself. We believe this has to do with the distribution of words in our data: While the data includes a large variety of words, it does not include many very similar pairs. In fact, of all possible pairs of unique training set words, fewer than $2 \\%$ have an edit distance below 5 characters. Therefore, there may not be sufficient information to learn to distinguish detailed differences among character sequences, and the cost-sensitive loss ultimately does not learn much more than to separate different words. In future work it would be interesting to experiment with data sets that have a larger variety of similar words. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 VISUALIZATION OF LEARNED EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            522,
+            516,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 gives a 2-dimensional t-SNE (van der Maaten & Hinton, 2008) visualization of selected acoustic and character sequences from the development set, including some that were seen in the training set and some previously unseen words. The previously seen words in this figure were selected uniformly at random among those that appear at least 15 times in the development set (the unseen words are the only six that appear at least 15 times in the development set). This visualization demonstrates that the acoustic embeddings cluster very tightly and are very close to the text embeddings, and that unseen words cluster nearly as well as previously seen ones. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While Figure 3 shows the relationship among the multiple acoustic embeddings and the text embeddings, the words are all very different so we cannot draw conclusions about the relationships between words. Figure 4 provides another visualization, this time exploring the relationship among the text embeddings of a number of closely related words, namely all development set words ending in “-ly”, “-ing”, and “-tion”. This visualization confirms that related words are embedded close together, with the words sharing a suffix forming fairly well-defined clusters. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            733
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            756,
+            318,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have presented an approach for jointly learning acoustic word embeddings and their orthographic counterparts. This multi-view approach produces improved acoustic word embedding performance over previous approaches, and also has the benefit that the same embeddings can be applied for both spoken and written query tasks. We have explored a variety of contrastive objectives: ones with a fixed margin that aim to separate same and different word pairs, as well as a cost-sensitive loss that aims to capture orthographic edit distances. While the losses generally perform similarly for word discrimination tasks, the cost-sensitive loss improves the correlation between embedding distances and orthographic distances. One interesting direction for future work is to directly use knowledge about phonetic pronunciations, in both evaluation and training. Another direction is to extend our approach to directly train on both word and non-word segments. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c2f0d642050b64e900351eedc1ff0cfc1f14c96aa149fba6cc6e339a7d8ef0f.jpg",
+        "image_caption": [
+            "Figure 3: Visualization via t-SNE of acoustic word embeddings (colored markers) and corresponding character sequence embeddings (text), for a set of development set words with at least 15 acoustic tokens. Words seen in training are in lower-case; unseen words are in upper-case. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            261,
+            128,
+            723,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/55e4866a47801c808bb2254e65ce6dee329cfb482f9799ded969933d263e1930.jpg",
+        "image_caption": [
+            "Figure 4: Visualization via $\\mathbf { t } { - } \\mathbf { S N E }$ of character sequence embeddings for words with the suffixes “-ly” (blue), “-ing” (red), and “-tion” (green). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            264,
+            502,
+            732,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            847,
+            326,
+            859
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by a Google Faculty Award and by NSF grant IIS-1321015. The opinions expressed in this work are those of the authors and do not necessarily reflect the views of the funding agency. This research used GPUs donated by NVIDIA Corporation. We thank Herman Kamper and Shane Settle for their assistance with the data and experimental setup. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xavier Anguera, Luis Javier Rodriguez-Fuentes, Igor Szoke, Andi Buzo, and Florian Metze. Query ¨ by example search on speech at mediaeval 2014. In MediaEval, 2014. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kartik Audhkhasi, Andrew Rosenberg, Abhinav Sethy, Bhuvana Ramabhadran, and Brian Kingsbury. End-to-end ASR-free keyword search from speech. arXiv preprint arXiv:1701.04313, 2017. ",
+        "bbox": [
+            173,
+            162,
+            823,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio and Georg Heigold. Word embeddings for speech recognition. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2014. ",
+        "bbox": [
+            173,
+            202,
+            823,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic ´ language model. Journal of Machine Learing Research, 3(Feb):1137–1155, 2003. ",
+        "bbox": [
+            169,
+            239,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jane Bromley, Isabelle Guyon, Yann Lecun, Eduard Sackinger, and Roopak Shah. Signature verifi- ¨ cation using a siamese time delay neural network. In Advances in Neural Information Processing Systems (NIPS), pp. 737–744, 1993. ",
+        "bbox": [
+            173,
+            277,
+            823,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael A Carlin, Samuel Thomas, Aren Jansen, and Hynek Hermansky. Rapid evaluation of speech representations for spoken term discovery. In Proc. Interspeech, 2011. ",
+        "bbox": [
+            171,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guoguo Chen, Carolina Parada, and Tara N Sainath. Query-by-example keyword spotting using long short-term memory networks. In Proc. ICASSP, 2015. ",
+        "bbox": [
+            169,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sumit Chopra, Raia Hadsell, and Yann LeCun. Learning a similarity metric discriminatively, with application to face verification. In IEEE Computer Society Conf. Computer Vision and Pattern Recognition, pp. 539–546, 2005. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yu-An Chung, Chao-Chung Wu, Chia-Hao Shen, and Hung-Yi Lee. Unsupervised learning of audio segment representations using sequence-to-sequence recurrent neural networks. In Proc. Interspeech, 2016. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Deerwester, Susan T Dumais, George W Furnas, Thomas K Landauer, and Richard Harshman. Indexing by latent semantic analysis. Journal of the American society for information science, 41 (6):391, 1990. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lev Finkelstein, Evgeniy Gabrilovich, Yossi Matias, Ehud Rivlin, Zach Solan, Gadi Wolfman, and Eytan Ruppin. Placing search in context: The concept revisited. In Proceedings of the 10th international conference on World Wide Web, 2001. ",
+        "bbox": [
+            173,
+            561,
+            826,
+            606
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan G Fiscus, Jerome Ajot, John S Garofolo, and George Doddingtion. Results of the 2006 spoken term detection evaluation. In Proc. SIGIR, volume 7, pp. 51–57. Citeseer, 2007. ",
+        "bbox": [
+            168,
+            613,
+            823,
+            645
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jort F Gemmeke, Tuomas Virtanen, and Antti Hurmalainen. Exemplar-based sparse representations for noise robust automatic speech recognition. IEEE Transactions on Acoustics, Speech, and Language Processing, 19(7):2067–2080, 2011. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sahar Ghannay, Yannick Esteve, Nathalie Camelin, and Paul Deleglise. Evaluation of acoustic word embeddings. In Proc. ACL Workshop on Evaluating Vector-Space Representations for NLP, 2016. ",
+        "bbox": [
+            171,
+            704,
+            823,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John J Godfrey, Edward C Holliman, and Jane McDaniel. SWITCHBOARD: Telephone speech corpus for research and development. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 1992. ",
+        "bbox": [
+            169,
+            741,
+            823,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Abdel rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2013. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            810
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In IEEE Computer Society Conf. Computer Vision and Pattern Recognition, 2006. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Harwath and James Glass. Deep multimodal semantic embeddings for speech and images. In Proc. IEEE Workshop on Automatic Speech Recognition and Understanding (ASRU), 2015. ",
+        "bbox": [
+            176,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Harwath and James R Glass. Learning word-like units from joint audio-visual analysis. arXiv preprint arXiv:1701.07481, 2017. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Harwath, Antonio Torralba, and James Glass. Unsupervised learning of spoken language with visual context. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann and Phil Blunsom. Multilingual distributed representations without word alignment. In Int. Conf. Learning Representations, 2014. arXiv:1312.6173 [cs.CL]. ",
+        "bbox": [
+            174,
+            142,
+            823,
+            172
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill, Roi Reichart, and Anna Korhonen. SimLex-999: Evaluating semantic models with (genuine) similarity estimation. Computational Linguistics, 41(4), 2015. ",
+        "bbox": [
+            174,
+            181,
+            823,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            220,
+            821,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baotian Hu, Zhengdong Lu, Hang Li, and Qingcai Chen. Convolutional neural network architectures for matching natural language sentences. In Advances in Neural Information Processing Systems (NIPS), 2014. ",
+        "bbox": [
+            173,
+            260,
+            826,
+            303
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohit Iyyer, Varun Manjunatha, Jordan Boyd-Graber, and Hal Daume III. Deep unordered com-´ position rivals syntactic methods for text classification. In Proc. Association for Computational Linguistics, 2015. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            356
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Herman Kamper, Micah Elsner, Aren Jansen, and Sharon J. Goldwater. Unsupervised neural network based feature extraction using weak top-down constraints. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2015. ",
+        "bbox": [
+            173,
+            366,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Herman Kamper, Weiran Wang, and Karen Livescu. Deep convolutional acoustic word embeddings using word-pair side information. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2016. ",
+        "bbox": [
+            171,
+            419,
+            821,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. ADAM: A method for stochastic optimization. In Int. Conf. Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            458,
+            820,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Kiros, Yukun Zhu, Ruslan R Salakhutdinov, Richard Zemel, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Skip-thought vectors. In Advances in Neural Information Processing Systems (NIPS), 2015. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keith Levin, Katharine Henry, Aren Jansen, and Karen Livescu. Fixed-dimensional acoustic embeddings of variable-length segments in low-resource settings. In Proc. IEEE Workshop on Automatic Speech Recognition and Understanding (ASRU), 2013. ",
+        "bbox": [
+            173,
+            550,
+            821,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keith Levin, Aren Jansen, and Benjamin Van Durme. Segmental acoustic indexing for zero resource keyword search. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2015. ",
+        "bbox": [
+            171,
+            603,
+            823,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew L Maas, Stephen D Miller, Tyler M O’neil, Andrew $\\mathrm { \\Delta Y N g }$ , and Patrick Nguyen. Word-level acoustic modeling with convolutional vector regression. In Proc. ICML Workshop on Representation Learning, 2012. ",
+        "bbox": [
+            173,
+            642,
+            823,
+            686
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems (NIPS), 2013. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andriy Mnih and Geoffrey Hinton. Three new graphical models for statistical language modelling. In ICML, 2007. ",
+        "bbox": [
+            171,
+            750,
+            821,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Ng. Multimodal deep learning. In ICML, pp. 689–696, 2011. ",
+        "bbox": [
+            169,
+            787,
+            825,
+            819
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global vectors for word representation. In Proc. Conference on Empirical Methods in Natural Language Processing, 2014. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shane Settle and Karen Livescu. Discriminative acoustic word embeddings: Recurrent neural network-based approaches. In Proc. IEEE Workshop on Spoken Language Technology (SLT), 2016. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Andrej Karpathy, Quoc V Le, Christopher D Manning, and Andrew Y Ng. Grounded compositional semantics for finding and describing images with sentences. Transactions of the Association for Computational Linguistics, 2:207–218, 2014. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn, Wenling Shang, and Honglak Lee. Improved multimodal deep learning with variation of information. In Advances in Neural Information Processing Systems (NIPS), pp. 2141–2149, 2014. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava and Ruslan Salakhutdinov. Multimodal learning with deep boltzmann machines. Journal of Machine Learing Research, pp. 2949–2980, 2014. ",
+        "bbox": [
+            171,
+            207,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Synnaeve, Thomas Schatz, and Emmanuel Dupoux. Phonetics embedding learning with side information. In Proc. IEEE Workshop on Spoken Language Technology (SLT), 2014. ",
+        "bbox": [
+            174,
+            243,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurens J. P. van der Maaten and Geoffrey E. Hinton. Visualizing data using $t$ -SNE. Journal of Machine Learing Research, 9:2579–2605, November 2008. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ivan Vendrov, Ryan Kiros, Sanja Fidler, and Raquel Urtasun. Order-embeddings of images and language. In Int. Conf. Learning Representations, 2016. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weiran Wang, Raman Arora, Karen Livescu, and Jeff Bilmes. On deep multi-view representation learning. In ICML, pp. 1083–1092, 2015. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Wieting, Mohit Bansal, Kevin Gimpel, and Karen Livescu. Towards universal paraphrastic sentence embeddings. In Int. Conf. Learning Representations, 2016. ",
+        "bbox": [
+            171,
+            395,
+            821,
+            424
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            406,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We first explore the effect of network architectures for our embedding models. We learn embeddings using objective obj0 and evaluate them on the acoustic and cross-view word discrimination tasks. The resulting average precisions on the development set are given in Table 4. All of the models were trained for 1000 epochs, except for the 1-layer unidirectional models which converged after 500 epochs. It is clear that bidirectional LSTMs are more successful than unidirectional LSTMs for these tasks, and two layers of LSTMs are much better than a single layer of LSTMs. We did not observe significant further improvement by using more than two layers of LSTMs. For all other experiments, we fix the architecture to 2-layer bidirectional LSTMs for each view. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            247
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/9da5c05799854c6ed991d0750d4ce837511acd8ecbc73badcf033c20a563a4bc.jpg",
+        "table_caption": [
+            "Dev AP Dev AP (acoustic word discrimination) (cross-view word discrimination) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>1-layer unidirectional</td><td>0.379</td><td>0.616</td></tr><tr><td>1-layer bidirectional</td><td>0.466</td><td>0.690</td></tr><tr><td>2-layer bidirectional</td><td>0.659</td><td>0.791</td></tr></table>",
+        "bbox": [
+            191,
+            287,
+            810,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Average precision (AP) for acoustic and cross-view word discrimination tasks on the development set, using embeddings learned with objective obj0 and different LSTM architectures. ",
+        "bbox": [
+            171,
+            342,
+            823,
+            372
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0618f23038e66a0aa68d56348d9bef2abac0f6d0be9848722320fd08dc601a54.jpg",
+        "image_caption": [
+            "Figure 5: Precision-recall curve (left: two-layer bidirectional LSTM trained with $\\mathrm { \\ o b j ^ { 0 } + o b j ^ { 2 } }$ for word discrimination task) and scatter plot of embedding distances vs. orthographic distances (right: cost-sensitive margin model for word similarity task), for our best embedding models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            158,
+            410,
+            808,
+            599
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5 we also give the precision-recall curve for our best models, as well as the scatter plot of cosine distances between acoustic embeddings vs. orthographic edit distances. ",
+        "bbox": [
+            173,
+            686,
+            823,
+            715
+        ],
+        "page_idx": 12
+    }
+]