Add files using upload-large-folder tool

parse/train/1NRMmEUyXMu/1NRMmEUyXMu.md

@@ -0,0 +1,346 @@
+# WORLD MODEL AS A GRAPH: LEARNING LATENT LANDMARKS FOR PLANNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Planning, the ability to analyze the structure of a problem in the large and decompose it into interrelated subproblems, is a hallmark of human intelligence. While deep reinforcement learning (RL) has shown great promise for solving relatively straightforward control tasks, it remains an open problem how to best incorporate planning into existing deep RL paradigms to handle increasingly complex environments. One prominent framework, Model-Based RL, learns a world model and plans using step-by-step virtual rollouts. This type of world model quickly diverges from reality when the planning horizon increases, thus struggling at long-horizon planning. How can we learn world models that endow agents with the ability to do temporally extended reasoning? In this work, we propose to learn graph-structured world models composed of sparse, multi-step transitions. We devise a novel algorithm to learn latent landmarks that are scattered (in terms of reachability) across the goal space as the nodes on the graph. In this same graph, the edges are the reachability estimates distilled from Q-functions. On a variety of high-dimensional continuous control tasks ranging from robotic manipulation to navigation, we demonstrate that our method, named $L ^ { 3 } P$ , significantly outperforms prior work, and is oftentimes the only method capable of leveraging both the robustness of model-free RL and generalization of graph-search algorithms. We believe our work is an important step towards scalable planning in reinforcement learning.
+
+# 1 INTRODUCTION
+
+An intelligent agent should be able to solve difficult problems by breaking them down into sequences of simpler problems. Classically, planning algorithms have been the tool of choice for endowing AI agents with the ability to reason over complex long-horizon problems (Doran & Michie, 1966; Hart et al., 1968). Recent years have seen an uptick in monographs examining the intersection of classical planning techniques – which excel at temporal abstraction – with deep reinforcement learning (RL) algorithms – which excel at state abstraction. Perhaps the ripest fruit born of this relationship is the AlphaGo algorithm, wherein a model free policy is combined with a MCTS (Coulom, 2006) planning algorithm to achieve superhuman performance on the game of Go (Silver et al., 2016a).
+
+In the field of robotics, progress on combining planning and reinforcement learning has been somewhat less rapid, although still resolute. Indeed, the laws of physics in the real world are infinitely more complex than the simple rules of Go. Unlike board games such as chess and Go, which have deterministic and known dynamics and discrete action space, robots have to deal with a probabilistic and unpredictable world, and the action space for robots is oftentimes continuous. As a result, planning in robotics presents a much harder problem. One general class of methods (Sutton, 1991) seeks to combine model-based planning and deep RL. These methods can be thought of as an extension of model-predictive control (MPC) algorithms, with the key difference being that the agent is trained over hypothetical experience in addition to the actually collected experience. The primary shortcoming of this class of methods is that, like MCTS in AlphaGo, they resort to planning with action sequences – forcing the robot to plan for each action at every hundred milliseconds. Planning on the level of action sequences is fundamentally bottlenecked by the accuracy of the learned dynamics model and the horizon of a task, as the learned world model quickly diverges over a long horizon. This limitation shows that world models in the traditional Model-based RL (MBRL) setting often fail to deliver the promise of planning.
+
+![](images/fc89e2710a4a54f0265190691ecc10f0fb1f19e49d0f207212d299f8609bb3b3.jpg)  
+Figure 1: MBRL versus $L ^ { 3 } P$ (World Model as a Graph). MBRL does step-by-step virtual rollouts with the world model and quickly diverges from reality when the planning horizon increases. $L ^ { 3 } P$ models the world as a graph of sparse multi-step transitions, where the nodes are learned latent landmarks and the edges are reachability estimates. $L ^ { 3 } P$ succeeds at temporally extended reasoning.
+
+Another general class of methods, Hierarchical RL (HRL), introduces a higher-level learner to address the problem of planning (Dayan & Hinton, 1993; Vezhnevets et al., 2017; Nachum et al., 2018). In this scenario, a goal-based RL agent serves as the worker, and a manager learns what sequences of goals it must set for the worker to achieve a complex task. While this is apparently a sound solution to the problem of planning, hierarchical learners neither explicitly learn a higher-level model of the world nor take advantage of the graph structure inherent to the problem of search.
+
+To better combine classical planning and reinforcement learning, we propose to learn graph-structured world models composed of sparse multi-step transitions. To model the world as a graph, we borrow a concept from the navigation literature – the idea of landmarks (Wang et al., 2008). Landmarks are essentially states that an agent can navigate between in order to complete tasks. However, rather than simply using previously seen states as landmarks, as is traditionally done, we will instead develop a novel algorithm to learn the landmarks used for planning. Our key insight is that by mapping previously achieved goals into a latent space that captures the temporal distance between goals, we can perform clustering in the latent space to group together goals that are easily reachable from one another. Subsequently, we can then decode the latent centroids to obtain a set of goals scattered (in terms of reachability) across the goal space. Since our learned landmarks are obtained from latent clustering, we call them latent landmarks. The chief algorithmic contribution of this paper is a new method for planning over learned latent landmarks for high-dimensional continuous control domains, which we name Learning Latent Landmarks for Planning $( L ^ { 3 } P )$ .
+
+The idea of reducing planning in RL to a graph search problem has enjoyed some attention recently (Savinov et al., 2018a; Eysenbach et al., 2019; Huang et al., 2019; Liu et al., 2019; Yang et al., 2020; Laskin et al., 2020). A key difference between those works and $L ^ { 3 } P$ is that our use of latent landmarks allows us to substantially reduce the size of the search space. What’s more, we make improvements to the graph search module and the online planning algorithm to improve the robustness and sample efficiency of our method. As a result of those decisions, our algorithm is able to achieve superior performance on a variety of robotics domains involving both navigation and manipulation. In addition to the results presented in Section 5, videos of our algorithm’s performance, and an analysis of the sub-tasks discovered by the latent landmarks, may be found at https://sites.google.com/view/latent-landmarks/.
+
+# 2 RELATED WORKS
+
+The problem of learning landmarks to aid in robotics problems has a long and rich history (Gillner & Mallot, 1998; Wang & Spelke, 2002; Wang et al., 2008). Prior art has been deeply rooted in the classical planning literature. For example, traditional methods would utilize Dijkstra et al. (1959) to plan over generated waypoints, SLAM (Durrant-Whyte & Bailey, 2006) to simultaneously integrate mapping, or the RRT algorithm (LaValle, 1998) for explicit path planning. The $\mathbf { A } ^ { * }$ algorithm (Hart et al., 1968) further improved the computational efficiency of Dijkstra. Those types of methods often heavily rely on a hand-crafted configuration space that provides prior knowledge.
+
+Planning is intimately related to model-based RL (MBRL), as the core ideas underlying learned models and planners can enjoy considerable overlap. Perhaps the most clear instance of this overlap is Model Predictive Control (MPC), and the related Dyna algorithm (Sutton, 1991). When combined with modern techniques (Kurutach et al., 2018; Luo et al., 2018; Nagabandi et al., 2018; Ha & Schmidhuber, 2018; Hafner et al., 2019; Wang & Ba, 2019; Janner et al., 2019), MBRL is able to achieve some level of success. Corneil et al. (2018) and Hafner et al. (2020) also learn a discrete latent representation of the environment in the MBRL framework. As discussed in the introduction, planning on action sequences will fundamentally struggle to scale in robotics.
+
+Our method will make extensive use of a parametric goal-based RL agent to accomplish low-level navigation between states. This area has seen rapid progress recently, largely stemming from the success of Hindsight Experience Replay (HER) (Andrychowicz et al., 2017). Several improvements to HER augment the goal relabeling and sampling strategies to improve performance (Nair et al., 2018; Pong et al., 2018; 2019; Zhao et al., 2019; Pitis et al., 2020). There have also been attempts at incorporating search as inductive biases within the value function (Silver et al., 2016b; Tamar et al., 2016; Farquhar et al., 2017; Racaniere et al., 2017; Lee et al., 2018; Srinivas et al., 2018). The focus \` of this line of work is to improve the low-level policy and is thus orthogonal to our work.
+
+Recent work in Hierarchical RL (HRL) builds upon goal-based RL by learning a high-level parametric manager that feeds goals to the low-level goal-based agent (Dayan & Hinton, 1993; Vezhnevets et al., 2017; Nachum et al., 2018). This can be viewed as a parametric alternative to classical planning, as discussed in the introduction. Recently, Jurgenson et al. (2020); Pertsch et al. (2020) have derived HRL methods that are intimately tied to tree search algorithms. These papers are further connected to a recent trend in the literature wherein classical search methods are combined with parametric control (Savinov et al., 2018a; Eysenbach et al., 2019; Huang et al., 2019; Liu et al., 2019; Yang et al., 2020; Laskin et al., 2020). Several of these articles will be discussed throughout this paper. LEAP (Nasiriany et al., 2019) also considers the problem of proposing sub-goals for a goal-conditioned agent: it uses a VAE (Kingma & Welling, 2013) and does CEM on the prior distribution to form the landmarks. Our method constrains the latent space with temporal reachability between goals, a concept previously explored in Savinov et al. (2018b), and uses latent clustering and graph search rather than sampling-based methods to learn and propose sub-goals.
+
+# 3 BACKGROUND
+
+We consider the problem of Multi-Goal RL under a Markov Decision Process (MDP) that is parameterized by $( S , A , \bar { \mathbb { P } } , G , \Psi , R , \rho _ { 0 } )$ . $S$ and $A$ are the state and action space. The probability distribution of the initial states is given by $\rho _ { 0 } ( s )$ , and $\mathbb { P } ( s ^ { \prime } | s , a )$ is the transition probability. $\Psi : S \mapsto G$ is a mapping from the state space to the goal space, which assumes that every state $s$ can be mapped to a corresponding achieved goal $g$ . The reward function $R$ can be defined as $R ( s , a , s ^ { \prime } , g ) = - \mathbb { 1 } \{ \Psi ( s ^ { \prime } ) \neq g \}$ . We further assume that each episode has a fixed horizon $T$ .
+
+The goal-conditioned policy is a probability distribution $\pi : S \times G \times A \to \mathbb { R } ^ { + }$ . The policy gives rise to trajectory samples of the form $\tau = \{ s _ { 0 } , a _ { 0 } , g , s _ { 1 } , \cdot \cdot \cdot s _ { T } \}$ . The purpose of the policy $\pi$ is to learn how to reach the goals drawn from the goal distribution $p _ { g }$ , which means maximizing the cumulative rewards. Together with a discount factor $\gamma \in ( 0 , 1 )$ , the objective is to maximize $\begin{array} { r } { \mathcal { I } ( \pi ) = \mathbb { E } _ { g \sim p _ { g } , \tau \sim \pi ( g ) } [ \sum _ { t = 0 } ^ { T - 1 } \gamma ^ { t } \cdot R ( s _ { t } , a _ { t } , s _ { t + 1 } , g ) ] } \end{array}$ . Q-learning provides a sample-efficient way to optimize the above objective by utilizing off-policy data stored in a replay buffer $B$ . $Q ( s , a , g )$ estimates the reward-to-go under the current policy $\pi$ conditioned upon the given goal. An additional technique, called Hindsight Experience Replay, or HER (Andrychowicz et al., 2017), uses hindsight relabelling to drastically speed up training. This relabeling crucially relies upon the mapping $\Psi : S \mapsto G$ in the multi-goal MDP setting. We can write the the joint objective of multi-goal Q-learning with HER as minimizing:
+
+$$
+\begin{array} { r l } & { \underset { Q } { \operatorname* { m i n } } \mathbb { E } _ { \mathrm { } } _ { \mathrm { } \mathrm { } \tau \sim { \cal B } , t \sim \{ 0 \cdot \tau - 1 \} } \ \Biggl ( Q ( s _ { t } , a _ { t } , g ) - \Bigl ( R ( s _ { t } , a _ { t } , s _ { t + 1 } , g ) + \gamma \cdot Q ( s _ { t + 1 } , a ^ { \prime } , g ) \Bigr ) \Biggr ) ^ { 2 } } \\ & { \qquad k \sim \{ t + 1 \cdots T \} , g = \Psi ( s _ { t } ) } \\ & { \qquad a ^ { \prime } \sim \pi ( \cdot | s _ { t + 1 } , g ) } \end{array}
+$$
+
+![](images/0a41fb1435dbfa5edad54c79fe7a3109308ca9fe4d3d4f7764111a5c7235c938.jpg)  
+Figure 2: An overview of $L ^ { 3 } P$ , which learns a small number of latent landmarks for planning. The main components of our method are: learning reachability estimates (via Q-learning and regression), learning a latent space (via an auto-encoder with reachability constraints), learning latent landmarks (via clustering in the latent space), graph search on the world model and online planning.
+
+# 4 THE $L ^ { 3 } P$ ALGORITHM
+
+Our overall objective in this section is to derive an algorithm that learns a small number of landmarks scattered across goal space in terms of reachability and use those learned landmarks for planning. There are three chief difficulties we must overcome when considering such an algorithm. First, how can we group together goals that are easily reachable from one another? The answer is to embed goals into a latent space, where the latent representation captures some notion of temporal distance between goals – in the sense that goals that would take many timesteps to navigate between are further apart in latent space. Second, we need to find a way to learn a sparse set of landmarks used for planning. Our method performs clustering on the constrained latent space, and decodes the learned centroids as the landmarks we seek. Finally, we need to develop a non-parametric planning algorithm responsible for selecting sequences of landmarks the agent must traverse to accomplish its high-level goal. The proposed online planning algorithm is simple, scalable, and robust.
+
+# 4.1 LEARNING A LATENT SPACE
+
+Let us consider the following question: “How should we go about learning a latent space of goals where the metric reflects reachability?” Suppose we have an auto-encoder (AE) in the agent’s goal space, with deterministic encoder $f _ { E }$ and decoder $f _ { D }$ . As usual, the reconstruction loss is given by $\begin{array} { r } { \bar { \mathcal { L } } _ { r e c } ( g ) = \left\| f _ { D } \big ( f _ { E } ( g ) \big ) - g \right\| _ { 2 } ^ { 2 } } \end{array}$ . We want to make sure that the distance between two latent codes would roughly correspond to the number of steps it would take the policy to go from one goal to another. Concretely, for any pair of goals $( g _ { 1 } , g _ { 2 } )$ , we optimize the following loss:
+
+$$
+\mathcal { L } _ { l a t e n t } ( g _ { 1 } , g _ { 2 } ) = \Bigg ( \big \| f _ { E } ( g _ { 1 } ) - f _ { E } ( g _ { 2 } ) \big \| _ { 2 } ^ { 2 } - \frac { 1 } { 2 } \Big ( V ( g _ { 1 } , g _ { 2 } ) + V ( g _ { 2 } , g _ { 1 } ) \Big ) \Bigg ) ^ { 2 }
+$$
+
+Where $V : G \times G \to \mathbb { R } ^ { + }$ is a mapping that estimates how many steps it would take the policy $\pi$ to go from one goal to another goal on average. By adding this constraint and solving a joint optimization $\mathcal { L } _ { r e c } + \lambda \cdot \mathcal { L } _ { l a t e n t }$ , the encoding-decoding mapping can no longer be arbitrary, giving more structure to the latent space. Goals that are close by in terms of reachability will be naturally clustered in the latent space, and interpolations between latent codes will lead to meaningful results.
+
+Of course, the constraint in Equation 2 is quite meaningless if we do not have a way to estimate the mapping $V$ . We will proceed towards this objective by noting the following interesting connection between multi-goal Q-functions and reachability. In the multi-goal RL framework considered in the background section, the reward is binary in nature. The agent receives a reward of $- 1$ until it reaches the goal, and then 0 when it reaches the desired goal. In this setting, the Q-function is implicitly estimating the number of steps it takes to reach the goal $g$ from the current state $s$ after the action $a$ is taken. Denote this quantity as $D ( s , a , g )$ , the Q-function can be re-written as:
+
+$$
+Q ( s , a , g ) = \sum _ { t = 0 } ^ { D ( s , a , g ) - 1 } \gamma ^ { t } \cdot ( - 1 ) + \sum _ { t = D ( s , a , g ) } ^ { T - 1 } \gamma ^ { t } \cdot 0 = - \frac { 1 - \gamma ^ { D ( s , a , g ) } } { 1 - \gamma }
+$$
+
+Choosing to parameterize Q-functions in this way disentangles the effect of $\gamma$ on multi-goal Qlearning. It also provides us with access the direct distance estimation function $D ( s , a , g )$ . We note
+
+that this distance is not a mathematical distance in the sense of a metric. Instead, we use the word distance to refer to the number of steps the policy $\pi$ needs to take in the environment.
+
+Given our tractable estimate of $D$ , it is now a straightforward matter to estimate the desired quantity $V$ , which approximates how many steps it takes the policy to transition between goals. To get the desired estimate, we regress $V$ towards $D$ as follows
+
+$$
+\displaystyle \operatorname* { m i n } _ { V } \mathbb { E } _ { \tau \sim B , t \sim \{ 0 \cdots T - 1 \} } \Biggl ( D \bigl ( s _ { t } , a _ { t } , \Psi ( s _ { k } ) \bigr ) - V \bigl ( \Psi ( s _ { t + 1 } ) , \Psi ( s _ { k } ) \bigr ) \Biggr ) ^ { 2 }
+$$
+
+where $\Psi$ is given by the environment to map the states to the goal space. One crucial detail is the use of $\Psi ( s _ { t + 1 } )$ rather than $\Psi ( s _ { t } )$ in the inputs to $V$ . This is due to the fact that $D : S \times A \times G \to \mathbb { R }$ outputs the number of steps to go after an action is taken, when the state has transitioned into $s _ { t + 1 }$ . The objective above provides an unbiased estimate of the average number of steps between two goals.
+
+The estimates $D$ and $V$ will prove useful beyond helping to optimize the auto-encoder in Equation 2.   
+They will prove essential in weighting and planning over latent landmark nodes in Section 4.3.
+
+# 4.2 LEARNING LATENT LANDMARKS
+
+Planning on a graph can be expensive, as the number of edges can grow quadratically with the number of nodes. To battle this issue in scalability, we use the constrained latent space to learn a sparse set of landmarks. A landmark can be thought of as a waypoint that the agent can pass through enroute to achieve a desired goal. Ideally, goals that are easily reachable from one another should be grouped to form one single landmark. Since our latent representation captures the temporal reachability between goals, this can be achieved by doing clustering in the latent space. The cluster centroids, when decoded from the decoder, will be precisely the latent landmarks we are seeking.
+
+Clustering proceeds as follows. For $N$ clusters to be learned, we define a mixture of Gaussians in the latent space with $N$ trainable latent centroids, $\{ \mathbf { c } _ { 1 } \cdots \mathbf { c } _ { N } \}$ , and a shared trainable variance vector $\pmb { \sigma }$ We maximize the evidence lower bound (ELBO) with a uniform prior $p ( \mathbf { c } )$ :
+
+$$
+\log p \Big ( z = f _ { E } ( g ) \Big ) \ge \mathbb { E } _ { q ( \mathbf { c } \mid z ) } \Big [ \log p ( z \mid \mathbf { c } ) \Big ] - D _ { K L } \Big ( q ( \mathbf { c } \mid z ) \mid \mid p ( \mathbf { c } ) \Big )
+$$
+
+Ideally, we would like each batch of data given to the latent clustering model to be representative of the whole replay buffer, such that the centroids will quickly learn to scatter out. To this end, we propose to use the Greedy Latent Sparsification (GLS) algorithm (Algorithm 2 in the Appendix) on each batch of data sampled from the replay before taking a gradient step with the batch. GLS is inspired by kmeans $^ { + + }$ (Arthur & Vassilvitskii, 2007), with several key differences: this sparsification process is used for both training and initialization, it uses a neural metric for determining the distance between data points, and that it is compatible with mini-batch-style gradient-based training.
+
+# 4.3 PLANNING WITH LATENT LANDMARKS
+
+Having derived a latent encoding algorithm and an algorithm for learning latent landmarks, we at last turn our attention to planning. While prior works simply solve for the shortest path, we employ a soft version of the Floyd algorithm, where the soft relaxation operations can be seen as a soft value iteration procedure (see Equation 7 in the Appendix).
+
+To construct a weight matrix that at first provides a raw distance estimate between latent landmarks, we begin by decoding the learned centroids in the latent space into the nodes in the graph $\{ f _ { D } ( \mathbf { c } _ { 1 } ) \cdot \cdot \cdot \bar { f _ { D } } ( \mathbf { c } _ { N } ) \}$ . To build the graph, we add two edges directed in reverse orders for every pair of latent landmarks. For instance, for an edge going from $f _ { D } ( \mathbf { c } _ { i } )$ to $f _ { D } ( \mathbf { c } _ { j } )$ , the weight on that edge is $- V ( f _ { D } ( { \bf c } _ { i } ) , f _ { D } ( { \bf c } _ { j } ) )$ . Notice that the distances are negated to be negative. At the start of an episode, the agent receives a goal $g$ , and we construct the following matrix of size $( N + 1 ) \times ( N + 1 ) ^ { \top }$ :
+
+$$
+W = \left( \begin{array} { c c c c } { { 0 } } & { { \ldots } } & { { - V ( f _ { D } ( \mathbf { c } _ { 1 } ) , f _ { D } ( \mathbf { c } _ { N } ) ) } } & { { - V ( f _ { D } ( \mathbf { c } _ { 1 } ) , g ) } } \\ { { \vdots } } & { { \ddots } } & { { \vdots } } & { { \vdots } } \\ { { - V ( f _ { D } ( \mathbf { c } _ { N } ) , f _ { D } ( \mathbf { c } _ { 1 } ) ) } } & { { \ldots } } & { { 0 } } & { { - V ( f _ { D } ( \mathbf { c } _ { N } ) , g ) } } \\ { { - \infty } } & { { \ldots } } & { { - \infty } } & { { 0 } } \end{array} \right)
+$$
+
+![](images/e20f37d59080eae85d0785eca9e35e6ecc1b649a502f71dd657b20f2dfd3e839.jpg)  
+Figure 3: For both Point and Ant, during training, the initialization state distribution and the goal proposal distribution are uniform around the maze. During test time, the agent is asked to traverse the longest path in the maze. The success rate on the test environment is reported in Figure 4. This environment demonstrates $L ^ { 3 } P$ ’s ability to generalize to longer horizon goals during test time.
+
+# Algorithm 1 Online Planning in $L ^ { 3 } P$
+
+Given: Environment env, initial state $s$ , goal $g$
+
+1: $\mathrm { { C n t } = 0 }$ . Sub $\Game = \mathbb { N } \mathrm { o n e }$ .   
+2: Solve for $d _ { c  g }$ with graph search.   
+3: for $t = 1$ to $T$ do $\triangleright$ One episode   
+4: if Cnt $\geq 1 . 0$ then   
+5: $\mathtt { C n t } = \mathtt { C n t } - 1$   
+6: else . We do not re-plan at every step   
+7: Calculate ds→c.   
+8: d ← ds→c + dc→g   
+9: if SubG 6= None then   
+10: $d [ \mathrm { { S u b G } ]  - \infty }$   
+11: end if . Remove the immediate   
+previous landmark   
+12: SubG, Cnt ← arg max d, − max d   
+13: end if   
+14: $a \sim \pi ( s , \mathtt { S u b G } )$ ; $s \gets \in \mathrm { n v }$ .step(a).   
+15: end for
+
+For online planning, when the agent receives a goal at the start of an episode, we use graph search to solve for $d _ { c  g }$ (which is fixed throughout an episode). For an observation state $s$ , the algorithm calculates $d _ { s  c }$ :
+
+$$
+\begin{array} { r } { d _ { s  c } = ( \begin{array} { c } { - D \big ( s , \pi ( s , f _ { D } ( \mathbf { c } _ { 1 } ) ) , f _ { D } ( \mathbf { c } _ { 1 } ) \big ) } \\ { \vdots } \\ { - D \big ( s , \pi ( s , f _ { D } ( \mathbf { c } _ { N } ) ) , f _ { D } ( \mathbf { c } _ { N } ) \big ) } \\ { - D \big ( s , \pi ( s , g ) , g \big ) } \end{array} ) } \end{array}
+$$
+
+The chosen landmark is subgoal $\gets$ arg $\operatorname* { m a x } ( d _ { s \to c } + d _ { c \to g } )$ . To further provide temporal abstraction and robustness, the agent will be asked to consistently pursue subgoal for $- d _ { s  c } [ \mathsf { s u b g o a l } ]$ number of steps, which is how many steps it thinks it will need. The proposed goal does not change during this period.
+
+The algorithm makes sure that the agent does not re-plan at every step, and this mechanism for temporal abstraction is crucial to its robustness. After this many steps, the agent will decide on the next landmark to pursue by re-calculating $d _ { s  c }$ , but the immediate previous landmark will not be considered as a candidate landmark. The reason is that, if the agent has failed to reach a self-proposed landmark within the reachability limit it has set for itself, then the agent should try something new for the immediate next goal rather than stick to the immediate previous landmark for another round. We have found that this simple algorithm helps the agent avoid getting stuck and improves the overall robustness of the agent.
+
+In summary, we have derived an algorithm that learns a sparse set of latent landmarks scattered across goal space in terms of reachability, and uses those learned landmarks for robust planning.
+
+# 5 EXPERIMENTS AND EVALUATION
+
+We investigate the impact of $L ^ { 3 } P$ in a variety of robotic manipulation and navigation environments. These include standard benchmarks such as Fetch-PickAndPlace, and more difficult environments such as AntMaze-Hard and Place-Inside-Box that have been engineered to require test-time generalization. Videos of our algorithm in action are available here: https: //sites.google.com/view/latent-landmarks/.
+
+# 5.1 BASELINES
+
+We compare our method with a variety of baselines. HER (Andrychowicz et al., 2017) is a model-free RL algorithm. SORB (Eysenbach et al., 2019) is a method that combines RL and graph search by using the entire replay buffer. Mapping State Space (MSS Huang et al. 2019) reduces the number
+
+![](images/bec23b0313e19e55e85b3079d8367c149af772360022bd08c196c5aab0b4b36b.jpg)  
+Figure 4: Test time success rate vs. total number of timesteps, on maze and robotic manipulation environments. During test time, new more difficult goals are selected. $L ^ { 3 } P$ shows more robust generalization much more quickly than other methods. For every environment except PointmMaze, $\bar { L } ^ { 3 } P$ is the only algorithm that consistently solves the task.
+
+![](images/d52222af0cdce0ccad0418ef8fcfd06994f1e7eb1314d998812057ab5fc30789.jpg)  
+Figure 5: Visualizing planning on AntMaze at test time. Read images from upper left to bottom right. The blue dots are the learned latent landmarks decoded from the latent centroids. The orange dot represents the ant’s present location in the maze. The red dot is the final goal that the agent needs to reach. At each step, the blue star indicates the landmark chosen by our planning algorithm. Whereas MSS and SORB sample 400 and hundreds of thousands of landmarks (respectively), our method obtains a lean graph that only contain 50 landmarks. $L ^ { 3 } P$ is the only method capable of achieving over $80 \%$ test success rate on AntMaze-Hard within 3M timesteps.
+
+![](images/aa4fc5de2e28f82b4caabbd147494c37f7e6fc86d1397c5c8078564fb1e8e331.jpg)  
+Figure 6: We consider two environments involving a fetch robot, a block, and a box. In Box-asidePickAndPlace, the fetch must learn to pick and place the block while avoiding collision with the box. In Place-Inside-Box, the fetch must pick the block and place it inside the box. We visualize the fetch states corresponding to learned landmarks in the second row of images.
+
+of vertices by sub-sampling the replay buffer. $L ^ { 3 } P$ , SORB, and MSS all use the same hindsight relabelling strategy proposed in HER. All of the domains are continuous control tasks, so we adopt DDPG (Lillicrap et al., 2015) as the learning algorithm for the low-level actor.
+
+# 5.2 GENERALIZATION TO LONGER HORIZONS
+
+The PointMaze-Hard and AntMaze-Hard environments introduced in Figure 5 are designed to test an agent’s ability to generalize to longer horizons. While PointMaze and AntMaze have been previously used in Duan et al. (2016); Huang et al. (2019); Pitis et al. (2020), we make slight changes to those environments in order to increase their difficulty. We use a short, 200-timestep time horizon during training and a $\rho _ { 0 }$ that is uniform in the maze. At test time, we always initialize the agent on one end of the maze, and set the goal on the other end. The horizon of the test environment is 500 steps. Crucially, no prior knowledge on the shape of the maze is given to the agent. We also set a much stricter threshold for determining whether an agent has reached the goal. In Figure 4, we see $L ^ { 3 } P$ is the only algorithm capable of solving AntMaze-Hard consistently.
+
+We observe an interesting trend where the success rates for other graph search methods crash and then slowly recover after making some initial progress. We postulate this occurs because methods that are based on using the entire replay or sub-sampling the replay for landmark selection will struggle as the buffer size increases. In contrast to these methods, $L ^ { 3 } \bar { P }$ does not exhibit such undesirable instability. The online planning algorithm in $L ^ { 3 } P$ , which effectively leverages temporal abstraction to improve robustness, also contributes to the asymptotic success rate. The result convincingly shows that, at least on the navigation tasks considered, $\bar { L } ^ { 3 } P$ is most effective at taking advantage of the problem’s inherent graph structure, and that learning latent landmarks is significantly more sample efficient and scalable than directly using or sub-sampling the replay buffer to build the graph.
+
+# 5.3 ROBOTIC MANIPULATION TASKS
+
+We also benchmark challenging robotic manipulations tasks with a Fetch robot introduced in Plappert et al. (2018); Andrychowicz et al. (2017). In Figure 6, we introduce two pick and place tasks involving a box on a table. In the Place-Inside-Box environment, we design a simple curriculum to cope with the difficulty of the task. During training, the goal distribution has $80 \%$ regular pick-and-place goals, enabling the agent to first learn how to fetch in general. Meanwhile, only $20 \%$ of the goals are inside the box, which is the harder part of the task. During testing, we evaluate the ability of the agent to pick the object from the table and place it inside the box. Our method achieves dominant performance in both learning speed and test-time generalization. We note that on those manipulation tasks considered, many prior planning methods hurt the performance of the model-free agent. Our method is the only one that is able to help the model-free agent learn faster and generalize better.
+
+# 5.4 UNDERSTANDING MODEL CHOICES IN $L ^ { 3 } P$
+
+We investigate $L ^ { 3 } P$ ’s sensitivity to different hyper-parameters and design choices via a set of ablation studies. More specifically, we study how the following factors affect the performance of $L ^ { 3 } P$ : number of latent landmarks, the choice of (online) planning algorithms, the choice of graph search algorithms, and edge cutoff threshold in graph search (a key hyper-parameter in the search module).
+
+The first question we try to understand is whether $L ^ { 3 } P$ is robust to the number of latent landmarks. In contrast to prior methods, $L ^ { 3 } P$ is able to learn the landmarks used for graph search from the agent’s own experience. We vary the number of learned landmarks in the challenging AntMaze-Hard environment, and we find that $L ^ { 3 } P$ is robust against a decreasing number of landmarks. This is expected, because the landmarks in the latent space of $L ^ { 3 } P$ will try to be equally scattered across the goal space according to the reachability metric. As the number of landmarks decreases, the learning procedure will automatically push the landmarks to be further away from one another.
+
+![](images/2e1eef2cccff8c3c18dd0eea9a85e82139b362cdc85639a6eb0c9e6466adbac7.jpg)
+
+![](images/5bdde49e76890351e2b87757f303eea29eb216f9b954e0a9f8a05f5646d92ec8.jpg)
+
+A key component in $L ^ { 3 } P$ is the online planning algorithm described in Algorithm 1. We find this algorithm to bear special importance to the good performance of $\dot { L ^ { 3 } } P$ . Our planning algorithm in $L ^ { 3 } P$ can take advantage of the temporal abstraction provided by the graph-structured world model. It does not re-plan at every step, but instead uses the reachability estimates to dynamically decide when to re-plan, striking a balance between adaptability and consistency in planning. This planner is also more tolerant of
+
+errors: it removes the immediate previous landmark when it re-plans, so that the agent will be less prone to getting stuck. A naive planner, on the other hand, simply re-calculates the shortest path at every step. The curve on the left shows that this planning algorithm is crucial to the success of $L ^ { 3 } P$ .
+
+The particular choice of graph search seems to have a small effect on the stability of learning. As explained Section 4.3 and Appendix A.2, we find that while employing the Floyd algorithm for graph search, a soft operation for relaxation leads to better stability during training. On the right, we show that a hard version of relaxation helps the agent take off faster but suffers from greater instability during policy improvement. The likely reason is that neural distance estimates are not entirely accurate, and in the presence of occasional bad edges, softmax in
+
+![](images/372919bab33755431b83ce4c989a6cc32cd38f0f1fe2defd8cbb3210e10bc306.jpg)
+
+Equation 7 improves robustness. We therefore use soft relaxation in our graph search module.
+
+![](images/d520da3f3efcfe0c5b00628b12ce50a1ef52c72206097bc4528762e31eb9622f.jpg)
+
+One of the most important hyper-parameters when combining RL with graph search is d max, the clipping threshold for the edges on the graph (Savinov et al., 2018a; Eysenbach et al., 2019; Huang et al., 2019; Laskin et al., 2020). The motivation for introducing this commonly used hyper-parameter is two-fold. Firstly, we only trust distance estimates when they are local. Secondly, we want the graph search module to produce sub-goals that are nearby. The d max value determines the maximum distance for each edge on the graph and masks out longer
+
+edges. One weakness of our current approach is that it is still quite sensitive to this hyper-parameter; a small change to $d$ max can have considerable impacts on learning. As this weakness is common to this class of approaches, we believe that further research is required to find other ways of encouraging search to be local. See Appendix A.2 for more details on implementing this clipping threshold.
+
+# 6 CLOSING REMARKS
+
+In this work, we introduce a way of learning graph-structured world models that endow agents with the ability to do temporally extended reasoning. The algorithm, $L ^ { 3 } P$ , learns a set of latent landmarks scattered across the goal space to enable scalable planning. We demonstrate that $L ^ { 3 } P$ achieves significantly better sample efficiency, higher asymptotic performance, and better generalization on a range of challenging robotic navigation and manipulation tasks. We hope that this work inspires more research in the direction of combining deep RL with classical planning.
+
+# REFERENCES
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in neural information processing systems, pp. 5048–5058, 2017.
+
+David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : The advantages of careful seeding. Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 2007.
+
+Dane Corneil, Wulfram Gerstner, and Johanni Brea. Efficient model-based deep reinforcement learning with variational state tabulation. arXiv preprint arXiv:1802.04325, 2018.
+
+Remi Coulom. Efficient selectivity and backup operators in monte-carlo tree search. In ´ International conference on computers and games, pp. 72–83. Springer, 2006.
+
+Peter Dayan and Geoffrey E Hinton. Feudal reinforcement learning. In Advances in neural information processing systems, pp. 271–278, 1993.
+
+Edsger W Dijkstra et al. A note on two problems in connexion with graphs. Numerische mathematik, 1(1):269–271, 1959.
+
+James E Doran and Donald Michie. Experiments with the graph traverser program. Proceedings of the Royal Society of London. Series A. Mathematical and Physical Sciences, 294(1437):235–259, 1966.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pp. 1329–1338, 2016.
+
+Hugh Durrant-Whyte and Tim Bailey. Simultaneous localization and mapping: part i. IEEE robotics & automation magazine, 13(2):99–110, 2006.
+
+Ben Eysenbach, Russ R Salakhutdinov, and Sergey Levine. Search on the replay buffer: Bridging planning and reinforcement learning. In Advances in Neural Information Processing Systems, pp. 15246–15257, 2019.
+
+Gregory Farquhar, Tim Rocktaschel, Maximilian Igl, and Shimon Whiteson. Treeqn and atreec: ¨ Differentiable tree-structured models for deep reinforcement learning. October 2017. URL http://arxiv.org/abs/1710.11417.
+
+Sabine Gillner and Hanspeter A Mallot. Navigation and acquisition of spatial knowledge in a virtual maze. Journal of cognitive neuroscience, 10(4):445–463, 1998.
+
+David Ha and Jurgen Schmidhuber. Recurrent world models facilitate policy evolution. In ¨ Advances in Neural Information Processing Systems, pp. 2450–2462, 2018.
+
+Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In International Conference on Machine Learning, pp. 2555–2565. PMLR, 2019.
+
+Danijar Hafner, Timothy Lillicrap, Mohammad Norouzi, and Jimmy Ba. Mastering atari with discrete world models. arXiv preprint arXiv:2010.02193, 2020.
+
+Peter E Hart, Nils J Nilsson, and Bertram Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE transactions on Systems Science and Cybernetics, 4(2):100–107, 1968.
+
+Zhiao Huang, Fangchen Liu, and Hao Su. Mapping state space using landmarks for universal goal reaching. In Advances in Neural Information Processing Systems, pp. 1942–1952, 2019.
+
+Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Model-based policy optimization. In Advances in Neural Information Processing Systems, pp. 12519–12530, 2019.
+
+Tom Jurgenson, Or Avner, Edward Groshev, and Aviv Tamar. Sub-goal trees–a framework for goal-based reinforcement learning. arXiv preprint arXiv:2002.12361, 2020.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Thanard Kurutach, Ignasi Clavera, Yan Duan, Aviv Tamar, and Pieter Abbeel. Model-ensemble trust-region policy optimization. arXiv preprint arXiv:1802.10592, 2018.
+
+Michael Laskin, Scott Emmons, Ajay Jain, Thanard Kurutach, Pieter Abbeel, and Deepak Pathak. Sparse graphical memory for robust planning. arXiv preprint arXiv:2003.06417, 2020.
+
+Steven M LaValle. Rapidly-exploring random trees: A new tool for path planning. 1998.
+
+Lisa Lee, Emilio Parisotto, Devendra Singh Chaplot, Eric Xing, and Ruslan Salakhutdinov. Gated path planning networks. June 2018. URL http://arxiv.org/abs/1806.06408.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Kara Liu, Thanard Kurutach, Christine Kit-Ching Tung, Pieter Abbeel, and Aviv Tamar. Hallucinative topological memory for zero-shot visual planning. ArXiv, 2019. URL https://www.semanticscholar.org/paper/ b8f0417844523d788630bb28a600dfeb74914e2d.
+
+Yuping Luo, Huazhe Xu, Yuanzhi Li, Yuandong Tian, Trevor Darrell, and Tengyu Ma. Algorithmic framework for model-based deep reinforcement learning with theoretical guarantees. arXiv preprint arXiv:1807.03858, 2018.
+
+Ofir Nachum, Shixiang Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforcement learning. In Advances in Neural Information Processing Systems, pp. 3303–3313, 2018.
+
+Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 7559–7566. IEEE, 2018.
+
+Ashvin V Nair, Vitchyr Pong, Murtaza Dalal, Shikhar Bahl, Steven Lin, and Sergey Levine. Visual reinforcement learning with imagined goals. In Advances in Neural Information Processing Systems, pp. 9191–9200, 2018.
+
+Soroush Nasiriany, Vitchyr Pong, Steven Lin, and Sergey Levine. Planning with goal-conditioned policies. In Advances in Neural Information Processing Systems, pp. 14843–14854, 2019.
+
+Karl Pertsch, Oleh Rybkin, Frederik Ebert, Chelsea Finn, Dinesh Jayaraman, and Sergey Levine. Long-horizon visual planning with goal-conditioned hierarchical predictors. arXiv preprint arXiv:2006.13205, 2020.
+
+Silviu Pitis, Harris Chan, Stephen Zhao, Bradly Stadie, and Jimmy Ba. Maximum entropy gain exploration for long horizon multi-goal reinforcement learning. arXiv preprint arXiv:2007.02832, 2020.
+
+Matthias Plappert, Marcin Andrychowicz, Alex Ray, Bob McGrew, Bowen Baker, Glenn Powell, Jonas Schneider, Josh Tobin, Maciek Chociej, Peter Welinder, et al. Multi-goal reinforcement learning: Challenging robotics environments and request for research. arXiv preprint arXiv:1802.09464, 2018.
+
+Vitchyr Pong, Shixiang Gu, Murtaza Dalal, and Sergey Levine. Temporal difference models: Modelfree deep rl for model-based control. arXiv preprint arXiv:1802.09081, 2018.
+
+Vitchyr H Pong, Murtaza Dalal, Steven Lin, Ashvin Nair, Shikhar Bahl, and Sergey Levine. Skew-fit: State-covering self-supervised reinforcement learning. arXiv preprint arXiv:1903.03698, 2019.
+
+Sebastien Racani ´ ere, Theophane Weber, David Reichert, Lars Buesing, Arthur Guez, Danilo \` Jimenez Rezende, Adria Puigdom \` enech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, Razvan Pas- \` canu, Peter Battaglia, Demis Hassabis, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. In I Guyon, U V Luxburg, S Bengio, H Wallach, R Fergus, S Vishwanathan, and R Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 5690–5701. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 7152-imagination-augmented-agents-for-deep-reinforcement-learning. pdf.
+
+Nikolay Savinov, Alexey Dosovitskiy, and Vladlen Koltun. Semi-parametric topological memory for navigation. arXiv preprint arXiv:1803.00653, 2018a.
+
+Nikolay Savinov, Anton Raichuk, Raphael Marinier, Damien Vincent, Marc Pollefeys, Timothy Lilli- ¨ crap, and Sylvain Gelly. Episodic curiosity through reachability. arXiv preprint arXiv:1810.02274, 2018b.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016a.
+
+David Silver, Hado van Hasselt, Matteo Hessel, Tom Schaul, Arthur Guez, Tim Harley, Gabriel DulacArnold, David Reichert, Neil Rabinowitz, Andre Barreto, and Thomas Degris. The predictron: End-to-end learning and planning. December 2016b. URL http://arxiv.org/abs/1612. 08810.
+
+Aravind Srinivas, Allan Jabri, Pieter Abbeel, Sergey Levine, and Chelsea Finn. Universal planning networks. April 2018. URL http://arxiv.org/abs/1804.00645.
+
+Richard S Sutton. Dyna, an integrated architecture for learning, planning, and reacting. ACM Sigart Bulletin, 2(4):160–163, 1991.
+
+Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. February 2016. URL http://arxiv.org/abs/1602.02867.
+
+Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg, David Silver, and Koray Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. arXiv preprint arXiv:1703.01161, 2017.
+
+Ranxiao Frances Wang and Elizabeth S Spelke. Human spatial representation: Insights from animals. Trends in cognitive sciences, 6(9):376–382, 2002.
+
+Tingwu Wang and Jimmy Ba. Exploring model-based planning with policy networks. arXiv preprint arXiv:1906.08649, 2019.
+
+Yang Wang, David Mulvaney, Ian Sillitoe, and Erick Swere. Robot navigation by waypoints. Journal of Intelligent and Robotic Systems, 52(2):175–207, 2008.
+
+Ge Yang, Amy Zhang, Ari S. Morcos, Joelle Pineau, Pieter Abbeel, and Roberto Calandra. Plan2vec: Unsupervised representation learning by latent plans. In Proceedings of The 2nd Annual Conference on Learning for Dynamics and Control, volume 120 of Proceedings of Machine Learning Research, pp. 1–12, 2020. arXiv:2005.03648.
+
+Rui Zhao, Xudong Sun, and Volker Tresp. Maximum entropy-regularized multi-goal reinforcement learning. arXiv preprint arXiv:1905.08786, 2019.
+
+# A APPENDIX
+
+A.1 GREEDY LATENT SPARSIFICATION
+
+Algorithm 2 Greedy Latent Sparsification (GLS) for Latent Cluster Training Given: Replay Buffer $B$ , Encoder $f _ { E }$ .   
+Initialize: LatentEmbeds $= \{ \}$ . $\triangleright$ Set of embeddings selected. 1: Sample $K$ achieved goals from $B$ .   
+2: Sample $k \sim \{ 0 \cdots K - 1 \}$ .   
+3: dist $= [ \| f _ { E } ( g _ { 1 } ) - f _ { E } ( \bar { g } _ { k } ) \| _ { 2 } ^ { 2 } , \cdot \cdot \cdot , \| f _ { E } ( g _ { K } ) - f _ { E } ( g _ { k } ) \| _ { 2 } ^ { 2 } ]$   
+4: for $\mathrm { i } = 1$ to $M$ do . Sub-sampling 5: $k $ arg max dist $[ k ]$   
+6: Add $f _ { E } ( g _ { k } )$ to LatentEmbeds.   
+7: NEWdist = [kfE(g1) − fE(gk)k22, · · · , kfE(gK ) − fE(gk)k22] 8: dist = ElementwiseMin(dist, NEWdist)   
+9: end for   
+10: Optimize equation 5 on LatentEmbeds.
+
+The Greedy Latent Sparsification (GLS) algorithm sub-samples a large batch by sparsification. GLS first randomly selects a latent embedding from the batch, and then greedily chooses the next embedding that is furthest away from already selected embeddings. After collecting some warm-up trajectories before planning starts (see Table 2) during training, we first use GLS to initialize the latent centroids, and then continue to use it to sample the batches used to train the latent clusters. As mentioned in Section 4.2, GLS is strongly inspired by Arthur & Vassilvitskii (2007), and this type of approach is known to improve clustering.
+
+# A.2 GRAPH SEARCH VIA SOFT VALUE ITERATIONS
+
+In this paper, we employ a soft version of Floyd algorithm, which we find to empirically work well. Rather than simply using the min operation to do relaxation, the soft value iteration procedure uses a sof t min operation when doing an update (note that, since we negated the distances to be negative in the weight matrix of the graph, which is Equation 6, the operations we use are actually max and softmax). The reason is that neural distances can be inconsistent and inaccurate at times, and using a soft operation makes the whole procedure more robust. More concretely, we repeat the following update on the weight matrix for $S$ steps with temperature $\beta$ :
+
+$$
+w _ { i , j } \gets \sum _ { k = 1 } ^ { N + 1 } \frac { \exp \frac { 1 } { \beta } ( w _ { i , k } + w _ { k , j } ) } { \sum _ { k ^ { \prime } = 1 } ^ { N + 1 } \exp \frac { 1 } { \beta } ( w _ { i , k ^ { \prime } } + w _ { k ^ { \prime } , j } ) } \Big ( w _ { i , k } + w _ { k , j } \Big )
+$$
+
+Following the practice in Eysenbach et al. (2019); Huang et al. (2019), we do the following initialization to the matrix in Equation 6: for entries smaller than the negative of $d _ { - } m a x$ , we penalize the entry by adding $- \infty$ to it (in this paper, we use $- 1 0 ^ { 6 }$ as the $- \infty$ value). The essential idea is that we only trust a neural estimate when it is local, and we rely on graph search to solve for global, longer-horizon distances. The $- \infty$ penalty effectively masks out those entries with large negative values in the softmax operation above. If we replace softmax with a hard max, we recover the original update in Floyd algorithm; we can interpolate between a hard Floyd and a soft Floyd by tuning the temperature $\beta$ .
+
+# A.3 HYPER-PARAMETERS
+
+Table 1 lists the common hyper-parameters across all environments. Table 2 lists the hyper-parameters that differ across the environments.
+
+Table 1: Hyper-parameters in Common   
+
+<table><tr><td rowspan=1 colspan=2>Parameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=2 colspan=2>DDPGoptimizernumber of hidden layers (all networks)number of hidden units per layernonlinearitypolyak for target network(T)target update intervalratio between env vs optimization stepsRandom action probabilityInitial random trajs per workerHindsight relabelling ratio</td><td rowspan=2 colspan=1>Adam (Kingma &amp; Ba, 2014)3256ReLU0.9951020.21000.85</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=2>LatentLandmarks&amp;Auto-encodernumber of hidden layersnumber of hidden units per layernonlinearityembedding size入 for reachability constraint losslearning rate</td><td rowspan=1 colspan=1>2128ReLU161.03e-4</td></tr><tr><td rowspan=1 colspan=2>Graph Searchprobability of using search during trainS (number of soft value iterations)β (temperature)</td><td rowspan=1 colspan=1>0.5201.1</td></tr></table>
+
+Table 2: Hyper-parameters for Each Environment   
+
+<table><tr><td colspan="4">Point-Maze Ant-Maze</td></tr><tr><td colspan="4">DDPG</td></tr><tr><td>Learning rate</td><td>2e-4</td><td>2e-4</td><td>1e-3 12</td></tr><tr><td>Number of workers Batch size</td><td>1 512</td><td>3 1024</td><td>1024</td></tr><tr><td>Action L2</td><td>0.5</td><td>0.05</td><td>0.01</td></tr><tr><td>Gamma</td><td>0.98</td><td>0.98</td><td>0.99</td></tr><tr><td>Action noise</td><td>0.2</td><td>0.2</td><td>0.1</td></tr><tr><td>Hindsight relabelling range</td><td>80</td><td>100</td><td>50</td></tr><tr><td colspan="4">LatentLandmarks&amp;Auto-encoder</td></tr><tr><td>Number of latent landmarks</td><td>50</td><td>50</td><td>80</td></tr><tr><td>Number of warm-up trajectories</td><td>500</td><td>500</td><td>6000</td></tr><tr><td>Batch size</td><td>256</td><td>256</td><td>150</td></tr><tr><td colspan="4">Graph Search</td></tr><tr><td>d_max (clipping threshold for distances)</td><td>20.0</td><td>20.0</td><td>15.0</td></tr><tr><td>Random landmarks added during train</td><td>150</td><td>150</td><td>20</td></tr></table>
+
+• We find that having a centralized replay for all parallel workers is significantly more sample efficient than having separate replays for each worker and simply averaging the gradients across workers.   
+• For Ant-Maze environment, we do grad norm clipping by a value of 15.0 for all networks. For Fetch tasks, we normalize the inputs by running means and standard deviations per input dimensions.   
+• Since $L ^ { 3 } P$ is able to decompose a long-horizon goal into many short-horizon goals, we shorten the range of future steps where we do hindsight relabelling; as a result, the agent can focus its optimization effort on more immediate goals. This corresponds to the hyperparameter: Hindsight relabelling range.   
+• During training, we collect $5 0 \%$ of the data without the planning module, and the other $5 0 \%$ of the data with planning. This corresponds to the hyper-parameter: probability of using search during train.   
+• At train time, to encourage exploration during planning, we temporarily add a small number of random landmarks from GLS (Algorithm 2) to the existing latent landmarks. A new set of random landmarks is selected for each episode before graph search starts (Algorithm 1). This corresponds to the hyper-parameter: Random landmarks added during train.   
+• We find that collecting a certain number of warm-up trajectories for every worker before the planning procedure starts (during training) and before GLS (Algorithm 2) is used for initialization to help improve the planning results. This corresponds to the hyper-parameter: Number of warm-up trajectories.

parse/train/1NRMmEUyXMu/1NRMmEUyXMu_content_list.json

@@ -0,0 +1,1708 @@
+[
+    {
+        "type": "text",
+        "text": "WORLD MODEL AS A GRAPH: LEARNING LATENT LANDMARKS FOR PLANNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            766,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Planning, the ability to analyze the structure of a problem in the large and decompose it into interrelated subproblems, is a hallmark of human intelligence. While deep reinforcement learning (RL) has shown great promise for solving relatively straightforward control tasks, it remains an open problem how to best incorporate planning into existing deep RL paradigms to handle increasingly complex environments. One prominent framework, Model-Based RL, learns a world model and plans using step-by-step virtual rollouts. This type of world model quickly diverges from reality when the planning horizon increases, thus struggling at long-horizon planning. How can we learn world models that endow agents with the ability to do temporally extended reasoning? In this work, we propose to learn graph-structured world models composed of sparse, multi-step transitions. We devise a novel algorithm to learn latent landmarks that are scattered (in terms of reachability) across the goal space as the nodes on the graph. In this same graph, the edges are the reachability estimates distilled from Q-functions. On a variety of high-dimensional continuous control tasks ranging from robotic manipulation to navigation, we demonstrate that our method, named $L ^ { 3 } P$ , significantly outperforms prior work, and is oftentimes the only method capable of leveraging both the robustness of model-free RL and generalization of graph-search algorithms. We believe our work is an important step towards scalable planning in reinforcement learning. ",
+        "bbox": [
+            233,
+            268,
+            766,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            336,
+            579
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An intelligent agent should be able to solve difficult problems by breaking them down into sequences of simpler problems. Classically, planning algorithms have been the tool of choice for endowing AI agents with the ability to reason over complex long-horizon problems (Doran & Michie, 1966; Hart et al., 1968). Recent years have seen an uptick in monographs examining the intersection of classical planning techniques – which excel at temporal abstraction – with deep reinforcement learning (RL) algorithms – which excel at state abstraction. Perhaps the ripest fruit born of this relationship is the AlphaGo algorithm, wherein a model free policy is combined with a MCTS (Coulom, 2006) planning algorithm to achieve superhuman performance on the game of Go (Silver et al., 2016a). ",
+        "bbox": [
+            174,
+            597,
+            825,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the field of robotics, progress on combining planning and reinforcement learning has been somewhat less rapid, although still resolute. Indeed, the laws of physics in the real world are infinitely more complex than the simple rules of Go. Unlike board games such as chess and Go, which have deterministic and known dynamics and discrete action space, robots have to deal with a probabilistic and unpredictable world, and the action space for robots is oftentimes continuous. As a result, planning in robotics presents a much harder problem. One general class of methods (Sutton, 1991) seeks to combine model-based planning and deep RL. These methods can be thought of as an extension of model-predictive control (MPC) algorithms, with the key difference being that the agent is trained over hypothetical experience in addition to the actually collected experience. The primary shortcoming of this class of methods is that, like MCTS in AlphaGo, they resort to planning with action sequences – forcing the robot to plan for each action at every hundred milliseconds. Planning on the level of action sequences is fundamentally bottlenecked by the accuracy of the learned dynamics model and the horizon of a task, as the learned world model quickly diverges over a long horizon. This limitation shows that world models in the traditional Model-based RL (MBRL) setting often fail to deliver the promise of planning. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc89e2710a4a54f0265190691ecc10f0fb1f19e49d0f207212d299f8609bb3b3.jpg",
+        "image_caption": [
+            "Figure 1: MBRL versus $L ^ { 3 } P$ (World Model as a Graph). MBRL does step-by-step virtual rollouts with the world model and quickly diverges from reality when the planning horizon increases. $L ^ { 3 } P$ models the world as a graph of sparse multi-step transitions, where the nodes are learned latent landmarks and the edges are reachability estimates. $L ^ { 3 } P$ succeeds at temporally extended reasoning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            104,
+            763,
+            287
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another general class of methods, Hierarchical RL (HRL), introduces a higher-level learner to address the problem of planning (Dayan & Hinton, 1993; Vezhnevets et al., 2017; Nachum et al., 2018). In this scenario, a goal-based RL agent serves as the worker, and a manager learns what sequences of goals it must set for the worker to achieve a complex task. While this is apparently a sound solution to the problem of planning, hierarchical learners neither explicitly learn a higher-level model of the world nor take advantage of the graph structure inherent to the problem of search. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To better combine classical planning and reinforcement learning, we propose to learn graph-structured world models composed of sparse multi-step transitions. To model the world as a graph, we borrow a concept from the navigation literature – the idea of landmarks (Wang et al., 2008). Landmarks are essentially states that an agent can navigate between in order to complete tasks. However, rather than simply using previously seen states as landmarks, as is traditionally done, we will instead develop a novel algorithm to learn the landmarks used for planning. Our key insight is that by mapping previously achieved goals into a latent space that captures the temporal distance between goals, we can perform clustering in the latent space to group together goals that are easily reachable from one another. Subsequently, we can then decode the latent centroids to obtain a set of goals scattered (in terms of reachability) across the goal space. Since our learned landmarks are obtained from latent clustering, we call them latent landmarks. The chief algorithmic contribution of this paper is a new method for planning over learned latent landmarks for high-dimensional continuous control domains, which we name Learning Latent Landmarks for Planning $( L ^ { 3 } P )$ . ",
+        "bbox": [
+            174,
+            468,
+            825,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The idea of reducing planning in RL to a graph search problem has enjoyed some attention recently (Savinov et al., 2018a; Eysenbach et al., 2019; Huang et al., 2019; Liu et al., 2019; Yang et al., 2020; Laskin et al., 2020). A key difference between those works and $L ^ { 3 } P$ is that our use of latent landmarks allows us to substantially reduce the size of the search space. What’s more, we make improvements to the graph search module and the online planning algorithm to improve the robustness and sample efficiency of our method. As a result of those decisions, our algorithm is able to achieve superior performance on a variety of robotics domains involving both navigation and manipulation. In addition to the results presented in Section 5, videos of our algorithm’s performance, and an analysis of the sub-tasks discovered by the latent landmarks, may be found at https://sites.google.com/view/latent-landmarks/. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            819,
+            354,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The problem of learning landmarks to aid in robotics problems has a long and rich history (Gillner & Mallot, 1998; Wang & Spelke, 2002; Wang et al., 2008). Prior art has been deeply rooted in the classical planning literature. For example, traditional methods would utilize Dijkstra et al. (1959) to plan over generated waypoints, SLAM (Durrant-Whyte & Bailey, 2006) to simultaneously integrate mapping, or the RRT algorithm (LaValle, 1998) for explicit path planning. The $\\mathbf { A } ^ { * }$ algorithm (Hart et al., 1968) further improved the computational efficiency of Dijkstra. Those types of methods often heavily rely on a hand-crafted configuration space that provides prior knowledge. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Planning is intimately related to model-based RL (MBRL), as the core ideas underlying learned models and planners can enjoy considerable overlap. Perhaps the most clear instance of this overlap is Model Predictive Control (MPC), and the related Dyna algorithm (Sutton, 1991). When combined with modern techniques (Kurutach et al., 2018; Luo et al., 2018; Nagabandi et al., 2018; Ha & Schmidhuber, 2018; Hafner et al., 2019; Wang & Ba, 2019; Janner et al., 2019), MBRL is able to achieve some level of success. Corneil et al. (2018) and Hafner et al. (2020) also learn a discrete latent representation of the environment in the MBRL framework. As discussed in the introduction, planning on action sequences will fundamentally struggle to scale in robotics. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our method will make extensive use of a parametric goal-based RL agent to accomplish low-level navigation between states. This area has seen rapid progress recently, largely stemming from the success of Hindsight Experience Replay (HER) (Andrychowicz et al., 2017). Several improvements to HER augment the goal relabeling and sampling strategies to improve performance (Nair et al., 2018; Pong et al., 2018; 2019; Zhao et al., 2019; Pitis et al., 2020). There have also been attempts at incorporating search as inductive biases within the value function (Silver et al., 2016b; Tamar et al., 2016; Farquhar et al., 2017; Racaniere et al., 2017; Lee et al., 2018; Srinivas et al., 2018). The focus \\` of this line of work is to improve the low-level policy and is thus orthogonal to our work. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            369
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recent work in Hierarchical RL (HRL) builds upon goal-based RL by learning a high-level parametric manager that feeds goals to the low-level goal-based agent (Dayan & Hinton, 1993; Vezhnevets et al., 2017; Nachum et al., 2018). This can be viewed as a parametric alternative to classical planning, as discussed in the introduction. Recently, Jurgenson et al. (2020); Pertsch et al. (2020) have derived HRL methods that are intimately tied to tree search algorithms. These papers are further connected to a recent trend in the literature wherein classical search methods are combined with parametric control (Savinov et al., 2018a; Eysenbach et al., 2019; Huang et al., 2019; Liu et al., 2019; Yang et al., 2020; Laskin et al., 2020). Several of these articles will be discussed throughout this paper. LEAP (Nasiriany et al., 2019) also considers the problem of proposing sub-goals for a goal-conditioned agent: it uses a VAE (Kingma & Welling, 2013) and does CEM on the prior distribution to form the landmarks. Our method constrains the latent space with temporal reachability between goals, a concept previously explored in Savinov et al. (2018b), and uses latent clustering and graph search rather than sampling-based methods to learn and propose sub-goals. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            555
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            326,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of Multi-Goal RL under a Markov Decision Process (MDP) that is parameterized by $( S , A , \\bar { \\mathbb { P } } , G , \\Psi , R , \\rho _ { 0 } )$ . $S$ and $A$ are the state and action space. The probability distribution of the initial states is given by $\\rho _ { 0 } ( s )$ , and $\\mathbb { P } ( s ^ { \\prime } | s , a )$ is the transition probability. $\\Psi : S \\mapsto G$ is a mapping from the state space to the goal space, which assumes that every state $s$ can be mapped to a corresponding achieved goal $g$ . The reward function $R$ can be defined as $R ( s , a , s ^ { \\prime } , g ) = - \\mathbb { 1 } \\{ \\Psi ( s ^ { \\prime } ) \\neq g \\}$ . We further assume that each episode has a fixed horizon $T$ . ",
+        "bbox": [
+            174,
+            609,
+            826,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal-conditioned policy is a probability distribution $\\pi : S \\times G \\times A \\to \\mathbb { R } ^ { + }$ . The policy gives rise to trajectory samples of the form $\\tau = \\{ s _ { 0 } , a _ { 0 } , g , s _ { 1 } , \\cdot \\cdot \\cdot s _ { T } \\}$ . The purpose of the policy $\\pi$ is to learn how to reach the goals drawn from the goal distribution $p _ { g }$ , which means maximizing the cumulative rewards. Together with a discount factor $\\gamma \\in ( 0 , 1 )$ , the objective is to maximize $\\begin{array} { r } { \\mathcal { I } ( \\pi ) = \\mathbb { E } _ { g \\sim p _ { g } , \\tau \\sim \\pi ( g ) } [ \\sum _ { t = 0 } ^ { T - 1 } \\gamma ^ { t } \\cdot R ( s _ { t } , a _ { t } , s _ { t + 1 } , g ) ] } \\end{array}$ . Q-learning provides a sample-efficient way to optimize the above objective by utilizing off-policy data stored in a replay buffer $B$ . $Q ( s , a , g )$ estimates the reward-to-go under the current policy $\\pi$ conditioned upon the given goal. An additional technique, called Hindsight Experience Replay, or HER (Andrychowicz et al., 2017), uses hindsight relabelling to drastically speed up training. This relabeling crucially relies upon the mapping $\\Psi : S \\mapsto G$ in the multi-goal MDP setting. We can write the the joint objective of multi-goal Q-learning with HER as minimizing: ",
+        "bbox": [
+            173,
+            700,
+            825,
+            859
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2cd0f689125fa9e1668543bacaaf1bb7f59220a3a5d3004ffd28c3c66b756c5f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\underset { Q } { \\operatorname* { m i n } } \\mathbb { E } _ { \\mathrm { } } _ { \\mathrm { } \\mathrm { } \\tau \\sim { \\cal B } , t \\sim \\{ 0 \\cdot \\tau - 1 \\} } \\ \\Biggl ( Q ( s _ { t } , a _ { t } , g ) - \\Bigl ( R ( s _ { t } , a _ { t } , s _ { t + 1 } , g ) + \\gamma \\cdot Q ( s _ { t + 1 } , a ^ { \\prime } , g ) \\Bigr ) \\Biggr ) ^ { 2 } } \\\\ & { \\qquad k \\sim \\{ t + 1 \\cdots T \\} , g = \\Psi ( s _ { t } ) } \\\\ & { \\qquad a ^ { \\prime } \\sim \\pi ( \\cdot | s _ { t + 1 } , g ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            864,
+            779,
+            929
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a41fb1435dbfa5edad54c79fe7a3109308ca9fe4d3d4f7764111a5c7235c938.jpg",
+        "image_caption": [
+            "Figure 2: An overview of $L ^ { 3 } P$ , which learns a small number of latent landmarks for planning. The main components of our method are: learning reachability estimates (via Q-learning and regression), learning a latent space (via an auto-encoder with reachability constraints), learning latent landmarks (via clustering in the latent space), graph search on the world model and online planning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            825,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 THE $L ^ { 3 } P$ ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            299,
+            393,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our overall objective in this section is to derive an algorithm that learns a small number of landmarks scattered across goal space in terms of reachability and use those learned landmarks for planning. There are three chief difficulties we must overcome when considering such an algorithm. First, how can we group together goals that are easily reachable from one another? The answer is to embed goals into a latent space, where the latent representation captures some notion of temporal distance between goals – in the sense that goals that would take many timesteps to navigate between are further apart in latent space. Second, we need to find a way to learn a sparse set of landmarks used for planning. Our method performs clustering on the constrained latent space, and decodes the learned centroids as the landmarks we seek. Finally, we need to develop a non-parametric planning algorithm responsible for selecting sequences of landmarks the agent must traverse to accomplish its high-level goal. The proposed online planning algorithm is simple, scalable, and robust. ",
+        "bbox": [
+            173,
+            323,
+            826,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 LEARNING A LATENT SPACE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            492,
+            413,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us consider the following question: “How should we go about learning a latent space of goals where the metric reflects reachability?” Suppose we have an auto-encoder (AE) in the agent’s goal space, with deterministic encoder $f _ { E }$ and decoder $f _ { D }$ . As usual, the reconstruction loss is given by $\\begin{array} { r } { \\bar { \\mathcal { L } } _ { r e c } ( g ) = \\left\\| f _ { D } \\big ( f _ { E } ( g ) \\big ) - g \\right\\| _ { 2 } ^ { 2 } } \\end{array}$ . We want to make sure that the distance between two latent codes would roughly correspond to the number of steps it would take the policy to go from one goal to another. Concretely, for any pair of goals $( g _ { 1 } , g _ { 2 } )$ , we optimize the following loss: ",
+        "bbox": [
+            173,
+            518,
+            826,
+            616
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cec70995753d245c9744e21dda3eef1fdde218808675c2987169799e7d619f6d.jpg",
+        "text": "$$\n\\mathcal { L } _ { l a t e n t } ( g _ { 1 } , g _ { 2 } ) = \\Bigg ( \\big \\| f _ { E } ( g _ { 1 } ) - f _ { E } ( g _ { 2 } ) \\big \\| _ { 2 } ^ { 2 } - \\frac { 1 } { 2 } \\Big ( V ( g _ { 1 } , g _ { 2 } ) + V ( g _ { 2 } , g _ { 1 } ) \\Big ) \\Bigg ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            619,
+            741,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Where $V : G \\times G \\to \\mathbb { R } ^ { + }$ is a mapping that estimates how many steps it would take the policy $\\pi$ to go from one goal to another goal on average. By adding this constraint and solving a joint optimization $\\mathcal { L } _ { r e c } + \\lambda \\cdot \\mathcal { L } _ { l a t e n t }$ , the encoding-decoding mapping can no longer be arbitrary, giving more structure to the latent space. Goals that are close by in terms of reachability will be naturally clustered in the latent space, and interpolations between latent codes will lead to meaningful results. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Of course, the constraint in Equation 2 is quite meaningless if we do not have a way to estimate the mapping $V$ . We will proceed towards this objective by noting the following interesting connection between multi-goal Q-functions and reachability. In the multi-goal RL framework considered in the background section, the reward is binary in nature. The agent receives a reward of $- 1$ until it reaches the goal, and then 0 when it reaches the desired goal. In this setting, the Q-function is implicitly estimating the number of steps it takes to reach the goal $g$ from the current state $s$ after the action $a$ is taken. Denote this quantity as $D ( s , a , g )$ , the Q-function can be re-written as: ",
+        "bbox": [
+            174,
+            742,
+            826,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65de749fb1af3b2466f6b5305b60980b00a01ca86d67aa142a6fa77ce72af9eb.jpg",
+        "text": "$$\nQ ( s , a , g ) = \\sum _ { t = 0 } ^ { D ( s , a , g ) - 1 } \\gamma ^ { t } \\cdot ( - 1 ) + \\sum _ { t = D ( s , a , g ) } ^ { T - 1 } \\gamma ^ { t } \\cdot 0 = - \\frac { 1 - \\gamma ^ { D ( s , a , g ) } } { 1 - \\gamma }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            845,
+            733,
+            892
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Choosing to parameterize Q-functions in this way disentangles the effect of $\\gamma$ on multi-goal Qlearning. It also provides us with access the direct distance estimation function $D ( s , a , g )$ . We note ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "that this distance is not a mathematical distance in the sense of a metric. Instead, we use the word distance to refer to the number of steps the policy $\\pi$ needs to take in the environment. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given our tractable estimate of $D$ , it is now a straightforward matter to estimate the desired quantity $V$ , which approximates how many steps it takes the policy to transition between goals. To get the desired estimate, we regress $V$ towards $D$ as follows ",
+        "bbox": [
+            174,
+            138,
+            825,
+            181
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/023cd786dd8a9982f7c5dd6d360c730d23e2b27c814cf59491a2cdfba42cdec7.jpg",
+        "text": "$$\n\\displaystyle \\operatorname* { m i n } _ { V } \\mathbb { E } _ { \\tau \\sim B , t \\sim \\{ 0 \\cdots T - 1 \\} } \\Biggl ( D \\bigl ( s _ { t } , a _ { t } , \\Psi ( s _ { k } ) \\bigr ) - V \\bigl ( \\Psi ( s _ { t + 1 } ) , \\Psi ( s _ { k } ) \\bigr ) \\Biggr ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            188,
+            720,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\Psi$ is given by the environment to map the states to the goal space. One crucial detail is the use of $\\Psi ( s _ { t + 1 } )$ rather than $\\Psi ( s _ { t } )$ in the inputs to $V$ . This is due to the fact that $D : S \\times A \\times G \\to \\mathbb { R }$ outputs the number of steps to go after an action is taken, when the state has transitioned into $s _ { t + 1 }$ . The objective above provides an unbiased estimate of the average number of steps between two goals. ",
+        "bbox": [
+            173,
+            246,
+            826,
+            303
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The estimates $D$ and $V$ will prove useful beyond helping to optimize the auto-encoder in Equation 2.   \nThey will prove essential in weighting and planning over latent landmark nodes in Section 4.3. ",
+        "bbox": [
+            176,
+            309,
+            826,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 LEARNING LATENT LANDMARKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            354,
+            446,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Planning on a graph can be expensive, as the number of edges can grow quadratically with the number of nodes. To battle this issue in scalability, we use the constrained latent space to learn a sparse set of landmarks. A landmark can be thought of as a waypoint that the agent can pass through enroute to achieve a desired goal. Ideally, goals that are easily reachable from one another should be grouped to form one single landmark. Since our latent representation captures the temporal reachability between goals, this can be achieved by doing clustering in the latent space. The cluster centroids, when decoded from the decoder, will be precisely the latent landmarks we are seeking. ",
+        "bbox": [
+            173,
+            373,
+            825,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Clustering proceeds as follows. For $N$ clusters to be learned, we define a mixture of Gaussians in the latent space with $N$ trainable latent centroids, $\\{ \\mathbf { c } _ { 1 } \\cdots \\mathbf { c } _ { N } \\}$ , and a shared trainable variance vector $\\pmb { \\sigma }$ We maximize the evidence lower bound (ELBO) with a uniform prior $p ( \\mathbf { c } )$ : ",
+        "bbox": [
+            174,
+            477,
+            825,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da4e62148312b0d143ce41f5faba6c12d4c2f8cef7e14b5ee70b6069da7c9fcb.jpg",
+        "text": "$$\n\\log p \\Big ( z = f _ { E } ( g ) \\Big ) \\ge \\mathbb { E } _ { q ( \\mathbf { c } \\mid z ) } \\Big [ \\log p ( z \\mid \\mathbf { c } ) \\Big ] - D _ { K L } \\Big ( q ( \\mathbf { c } \\mid z ) \\mid \\mid p ( \\mathbf { c } ) \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            526,
+            725,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Ideally, we would like each batch of data given to the latent clustering model to be representative of the whole replay buffer, such that the centroids will quickly learn to scatter out. To this end, we propose to use the Greedy Latent Sparsification (GLS) algorithm (Algorithm 2 in the Appendix) on each batch of data sampled from the replay before taking a gradient step with the batch. GLS is inspired by kmeans $^ { + + }$ (Arthur & Vassilvitskii, 2007), with several key differences: this sparsification process is used for both training and initialization, it uses a neural metric for determining the distance between data points, and that it is compatible with mini-batch-style gradient-based training. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            665
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 PLANNING WITH LATENT LANDMARKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            488,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Having derived a latent encoding algorithm and an algorithm for learning latent landmarks, we at last turn our attention to planning. While prior works simply solve for the shortest path, we employ a soft version of the Floyd algorithm, where the soft relaxation operations can be seen as a soft value iteration procedure (see Equation 7 in the Appendix). ",
+        "bbox": [
+            173,
+            699,
+            825,
+            756
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To construct a weight matrix that at first provides a raw distance estimate between latent landmarks, we begin by decoding the learned centroids in the latent space into the nodes in the graph $\\{ f _ { D } ( \\mathbf { c } _ { 1 } ) \\cdot \\cdot \\cdot \\bar { f _ { D } } ( \\mathbf { c } _ { N } ) \\}$ . To build the graph, we add two edges directed in reverse orders for every pair of latent landmarks. For instance, for an edge going from $f _ { D } ( \\mathbf { c } _ { i } )$ to $f _ { D } ( \\mathbf { c } _ { j } )$ , the weight on that edge is $- V ( f _ { D } ( { \\bf c } _ { i } ) , f _ { D } ( { \\bf c } _ { j } ) )$ . Notice that the distances are negated to be negative. At the start of an episode, the agent receives a goal $g$ , and we construct the following matrix of size $( N + 1 ) \\times ( N + 1 ) ^ { \\top }$ : ",
+        "bbox": [
+            173,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e60ae703f82291ba119c5016f26d55b826f0844f5e69b46ca6b0b3741b60a422.jpg",
+        "text": "$$\nW = \\left( \\begin{array} { c c c c } { { 0 } } & { { \\ldots } } & { { - V ( f _ { D } ( \\mathbf { c } _ { 1 } ) , f _ { D } ( \\mathbf { c } _ { N } ) ) } } & { { - V ( f _ { D } ( \\mathbf { c } _ { 1 } ) , g ) } } \\\\ { { \\vdots } } & { { \\ddots } } & { { \\vdots } } & { { \\vdots } } \\\\ { { - V ( f _ { D } ( \\mathbf { c } _ { N } ) , f _ { D } ( \\mathbf { c } _ { 1 } ) ) } } & { { \\ldots } } & { { 0 } } & { { - V ( f _ { D } ( \\mathbf { c } _ { N } ) , g ) } } \\\\ { { - \\infty } } & { { \\ldots } } & { { - \\infty } } & { { 0 } } \\end{array} \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            852,
+            767,
+            921
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e20f37d59080eae85d0785eca9e35e6ecc1b649a502f71dd657b20f2dfd3e839.jpg",
+        "image_caption": [
+            "Figure 3: For both Point and Ant, during training, the initialization state distribution and the goal proposal distribution are uniform around the maze. During test time, the agent is asked to traverse the longest path in the maze. The success rate on the test environment is reported in Figure 4. This environment demonstrates $L ^ { 3 } P$ ’s ability to generalize to longer horizon goals during test time. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            101,
+            756,
+            213
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Online Planning in $L ^ { 3 } P$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            315,
+            421,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given: Environment env, initial state $s$ , goal $g$ ",
+        "bbox": [
+            173,
+            333,
+            488,
+            347
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: $\\mathrm { { C n t } = 0 }$ . Sub $\\Game = \\mathbb { N } \\mathrm { o n e }$ .   \n2: Solve for $d _ { c  g }$ with graph search.   \n3: for $t = 1$ to $T$ do $\\triangleright$ One episode   \n4: if Cnt $\\geq 1 . 0$ then   \n5: $\\mathtt { C n t } = \\mathtt { C n t } - 1$   \n6: else . We do not re-plan at every step   \n7: Calculate ds→c.   \n8: d ← ds→c + dc→g   \n9: if SubG 6= None then   \n10: $d [ \\mathrm { { S u b G } ]  - \\infty }$   \n11: end if . Remove the immediate   \nprevious landmark   \n12: SubG, Cnt ← arg max d, − max d   \n13: end if   \n14: $a \\sim \\pi ( s , \\mathtt { S u b G } )$ ; $s \\gets \\in \\mathrm { n v }$ .step(a).   \n15: end for ",
+        "bbox": [
+            178,
+            348,
+            488,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For online planning, when the agent receives a goal at the start of an episode, we use graph search to solve for $d _ { c  g }$ (which is fixed throughout an episode). For an observation state $s$ , the algorithm calculates $d _ { s  c }$ : ",
+        "bbox": [
+            509,
+            308,
+            825,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14c2c2e5d8bb2b3135d33be5310ca431260fb4245059971a942330d1b0c83258.jpg",
+        "text": "$$\n\\begin{array} { r } { d _ { s  c } = ( \\begin{array} { c } { - D \\big ( s , \\pi ( s , f _ { D } ( \\mathbf { c } _ { 1 } ) ) , f _ { D } ( \\mathbf { c } _ { 1 } ) \\big ) } \\\\ { \\vdots } \\\\ { - D \\big ( s , \\pi ( s , f _ { D } ( \\mathbf { c } _ { N } ) ) , f _ { D } ( \\mathbf { c } _ { N } ) \\big ) } \\\\ { - D \\big ( s , \\pi ( s , g ) , g \\big ) } \\end{array} ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            517,
+            383,
+            816,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The chosen landmark is subgoal $\\gets$ arg $\\operatorname* { m a x } ( d _ { s \\to c } + d _ { c \\to g } )$ . To further provide temporal abstraction and robustness, the agent will be asked to consistently pursue subgoal for $- d _ { s  c } [ \\mathsf { s u b g o a l } ]$ number of steps, which is how many steps it thinks it will need. The proposed goal does not change during this period. ",
+        "bbox": [
+            509,
+            463,
+            825,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The algorithm makes sure that the agent does not re-plan at every step, and this mechanism for temporal abstraction is crucial to its robustness. After this many steps, the agent will decide on the next landmark to pursue by re-calculating $d _ { s  c }$ , but the immediate previous landmark will not be considered as a candidate landmark. The reason is that, if the agent has failed to reach a self-proposed landmark within the reachability limit it has set for itself, then the agent should try something new for the immediate next goal rather than stick to the immediate previous landmark for another round. We have found that this simple algorithm helps the agent avoid getting stuck and improves the overall robustness of the agent. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In summary, we have derived an algorithm that learns a sparse set of latent landmarks scattered across goal space in terms of reachability, and uses those learned landmarks for robust planning. ",
+        "bbox": [
+            173,
+            698,
+            823,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS AND EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            748,
+            482,
+            763
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We investigate the impact of $L ^ { 3 } P$ in a variety of robotic manipulation and navigation environments. These include standard benchmarks such as Fetch-PickAndPlace, and more difficult environments such as AntMaze-Hard and Place-Inside-Box that have been engineered to require test-time generalization. Videos of our algorithm in action are available here: https: //sites.google.com/view/latent-landmarks/. ",
+        "bbox": [
+            174,
+            780,
+            826,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            862,
+            294,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our method with a variety of baselines. HER (Andrychowicz et al., 2017) is a model-free RL algorithm. SORB (Eysenbach et al., 2019) is a method that combines RL and graph search by using the entire replay buffer. Mapping State Space (MSS Huang et al. 2019) reduces the number ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/bec23b0313e19e55e85b3079d8367c149af772360022bd08c196c5aab0b4b36b.jpg",
+        "image_caption": [
+            "Figure 4: Test time success rate vs. total number of timesteps, on maze and robotic manipulation environments. During test time, new more difficult goals are selected. $L ^ { 3 } P$ shows more robust generalization much more quickly than other methods. For every environment except PointmMaze, $\\bar { L } ^ { 3 } P$ is the only algorithm that consistently solves the task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            108,
+            792,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d52222af0cdce0ccad0418ef8fcfd06994f1e7eb1314d998812057ab5fc30789.jpg",
+        "image_caption": [
+            "Figure 5: Visualizing planning on AntMaze at test time. Read images from upper left to bottom right. The blue dots are the learned latent landmarks decoded from the latent centroids. The orange dot represents the ant’s present location in the maze. The red dot is the final goal that the agent needs to reach. At each step, the blue star indicates the landmark chosen by our planning algorithm. Whereas MSS and SORB sample 400 and hundreds of thousands of landmarks (respectively), our method obtains a lean graph that only contain 50 landmarks. $L ^ { 3 } P$ is the only method capable of achieving over $80 \\%$ test success rate on AntMaze-Hard within 3M timesteps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            416,
+            816,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa4fc5de2e28f82b4caabbd147494c37f7e6fc86d1397c5c8078564fb1e8e331.jpg",
+        "image_caption": [
+            "Figure 6: We consider two environments involving a fetch robot, a block, and a box. In Box-asidePickAndPlace, the fetch must learn to pick and place the block while avoiding collision with the box. In Place-Inside-Box, the fetch must pick the block and place it inside the box. We visualize the fetch states corresponding to learned landmarks in the second row of images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            277,
+            685,
+            720,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "of vertices by sub-sampling the replay buffer. $L ^ { 3 } P$ , SORB, and MSS all use the same hindsight relabelling strategy proposed in HER. All of the domains are continuous control tasks, so we adopt DDPG (Lillicrap et al., 2015) as the learning algorithm for the low-level actor. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 GENERALIZATION TO LONGER HORIZONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            165,
+            506,
+            179
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The PointMaze-Hard and AntMaze-Hard environments introduced in Figure 5 are designed to test an agent’s ability to generalize to longer horizons. While PointMaze and AntMaze have been previously used in Duan et al. (2016); Huang et al. (2019); Pitis et al. (2020), we make slight changes to those environments in order to increase their difficulty. We use a short, 200-timestep time horizon during training and a $\\rho _ { 0 }$ that is uniform in the maze. At test time, we always initialize the agent on one end of the maze, and set the goal on the other end. The horizon of the test environment is 500 steps. Crucially, no prior knowledge on the shape of the maze is given to the agent. We also set a much stricter threshold for determining whether an agent has reached the goal. In Figure 4, we see $L ^ { 3 } P$ is the only algorithm capable of solving AntMaze-Hard consistently. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            309
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observe an interesting trend where the success rates for other graph search methods crash and then slowly recover after making some initial progress. We postulate this occurs because methods that are based on using the entire replay or sub-sampling the replay for landmark selection will struggle as the buffer size increases. In contrast to these methods, $L ^ { 3 } \\bar { P }$ does not exhibit such undesirable instability. The online planning algorithm in $L ^ { 3 } P$ , which effectively leverages temporal abstraction to improve robustness, also contributes to the asymptotic success rate. The result convincingly shows that, at least on the navigation tasks considered, $\\bar { L } ^ { 3 } P$ is most effective at taking advantage of the problem’s inherent graph structure, and that learning latent landmarks is significantly more sample efficient and scalable than directly using or sub-sampling the replay buffer to build the graph. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            441
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 ROBOTIC MANIPULATION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            459,
+            442,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also benchmark challenging robotic manipulations tasks with a Fetch robot introduced in Plappert et al. (2018); Andrychowicz et al. (2017). In Figure 6, we introduce two pick and place tasks involving a box on a table. In the Place-Inside-Box environment, we design a simple curriculum to cope with the difficulty of the task. During training, the goal distribution has $80 \\%$ regular pick-and-place goals, enabling the agent to first learn how to fetch in general. Meanwhile, only $20 \\%$ of the goals are inside the box, which is the harder part of the task. During testing, we evaluate the ability of the agent to pick the object from the table and place it inside the box. Our method achieves dominant performance in both learning speed and test-time generalization. We note that on those manipulation tasks considered, many prior planning methods hurt the performance of the model-free agent. Our method is the only one that is able to help the model-free agent learn faster and generalize better. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            618
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 UNDERSTANDING MODEL CHOICES IN $L ^ { 3 } P$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            636,
+            517,
+            651
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We investigate $L ^ { 3 } P$ ’s sensitivity to different hyper-parameters and design choices via a set of ablation studies. More specifically, we study how the following factors affect the performance of $L ^ { 3 } P$ : number of latent landmarks, the choice of (online) planning algorithms, the choice of graph search algorithms, and edge cutoff threshold in graph search (a key hyper-parameter in the search module). ",
+        "bbox": [
+            174,
+            664,
+            826,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The first question we try to understand is whether $L ^ { 3 } P$ is robust to the number of latent landmarks. In contrast to prior methods, $L ^ { 3 } P$ is able to learn the landmarks used for graph search from the agent’s own experience. We vary the number of learned landmarks in the challenging AntMaze-Hard environment, and we find that $L ^ { 3 } P$ is robust against a decreasing number of landmarks. This is expected, because the landmarks in the latent space of $L ^ { 3 } P$ will try to be equally scattered across the goal space according to the reachability metric. As the number of landmarks decreases, the learning procedure will automatically push the landmarks to be further away from one another. ",
+        "bbox": [
+            174,
+            728,
+            485,
+            909
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e1eef2cccff8c3c18dd0eea9a85e82139b362cdc85639a6eb0c9e6466adbac7.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            744,
+            818,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            907,
+            735,
+            921
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5bdde49e76890351e2b87757f303eea29eb216f9b954e0a9f8a05f5646d92ec8.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            106,
+            495,
+            231
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A key component in $L ^ { 3 } P$ is the online planning algorithm described in Algorithm 1. We find this algorithm to bear special importance to the good performance of $\\dot { L ^ { 3 } } P$ . Our planning algorithm in $L ^ { 3 } P$ can take advantage of the temporal abstraction provided by the graph-structured world model. It does not re-plan at every step, but instead uses the reachability estimates to dynamically decide when to re-plan, striking a balance between adaptability and consistency in planning. This planner is also more tolerant of ",
+        "bbox": [
+            514,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "errors: it removes the immediate previous landmark when it re-plans, so that the agent will be less prone to getting stuck. A naive planner, on the other hand, simply re-calculates the shortest path at every step. The curve on the left shows that this planning algorithm is crucial to the success of $L ^ { 3 } P$ . ",
+        "bbox": [
+            173,
+            257,
+            826,
+            299
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The particular choice of graph search seems to have a small effect on the stability of learning. As explained Section 4.3 and Appendix A.2, we find that while employing the Floyd algorithm for graph search, a soft operation for relaxation leads to better stability during training. On the right, we show that a hard version of relaxation helps the agent take off faster but suffers from greater instability during policy improvement. The likely reason is that neural distance estimates are not entirely accurate, and in the presence of occasional bad edges, softmax in ",
+        "bbox": [
+            174,
+            305,
+            486,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/372919bab33755431b83ce4c989a6cc32cd38f0f1fe2defd8cbb3210e10bc306.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            323,
+            818,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Equation 7 improves robustness. We therefore use soft relaxation in our graph search module. ",
+        "bbox": [
+            166,
+            472,
+            785,
+            486
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d520da3f3efcfe0c5b00628b12ce50a1ef52c72206097bc4528762e31eb9622f.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            510,
+            495,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One of the most important hyper-parameters when combining RL with graph search is d max, the clipping threshold for the edges on the graph (Savinov et al., 2018a; Eysenbach et al., 2019; Huang et al., 2019; Laskin et al., 2020). The motivation for introducing this commonly used hyper-parameter is two-fold. Firstly, we only trust distance estimates when they are local. Secondly, we want the graph search module to produce sub-goals that are nearby. The d max value determines the maximum distance for each edge on the graph and masks out longer ",
+        "bbox": [
+            514,
+            493,
+            825,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "edges. One weakness of our current approach is that it is still quite sensitive to this hyper-parameter; a small change to $d$ max can have considerable impacts on learning. As this weakness is common to this class of approaches, we believe that further research is required to find other ways of encouraging search to be local. See Appendix A.2 for more details on implementing this clipping threshold. ",
+        "bbox": [
+            174,
+            659,
+            826,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CLOSING REMARKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            372,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce a way of learning graph-structured world models that endow agents with the ability to do temporally extended reasoning. The algorithm, $L ^ { 3 } P$ , learns a set of latent landmarks scattered across the goal space to enable scalable planning. We demonstrate that $L ^ { 3 } P$ achieves significantly better sample efficiency, higher asymptotic performance, and better generalization on a range of challenging robotic navigation and manipulation tasks. We hope that this work inspires more research in the direction of combining deep RL with classical planning. ",
+        "bbox": [
+            173,
+            756,
+            825,
+            839
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in neural information processing systems, pp. 5048–5058, 2017. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : The advantages of careful seeding. Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 2007. ",
+        "bbox": [
+            173,
+            176,
+            823,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dane Corneil, Wulfram Gerstner, and Johanni Brea. Efficient model-based deep reinforcement learning with variational state tabulation. arXiv preprint arXiv:1802.04325, 2018. ",
+        "bbox": [
+            173,
+            213,
+            823,
+            243
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Remi Coulom. Efficient selectivity and backup operators in monte-carlo tree search. In ´ International conference on computers and games, pp. 72–83. Springer, 2006. ",
+        "bbox": [
+            171,
+            251,
+            823,
+            281
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Dayan and Geoffrey E Hinton. Feudal reinforcement learning. In Advances in neural information processing systems, pp. 271–278, 1993. ",
+        "bbox": [
+            173,
+            289,
+            825,
+            318
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Edsger W Dijkstra et al. A note on two problems in connexion with graphs. Numerische mathematik, 1(1):269–271, 1959. ",
+        "bbox": [
+            169,
+            325,
+            826,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James E Doran and Donald Michie. Experiments with the graph traverser program. Proceedings of the Royal Society of London. Series A. Mathematical and Physical Sciences, 294(1437):235–259, 1966. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            405
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pp. 1329–1338, 2016. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hugh Durrant-Whyte and Tim Bailey. Simultaneous localization and mapping: part i. IEEE robotics & automation magazine, 13(2):99–110, 2006. ",
+        "bbox": [
+            171,
+            465,
+            825,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ben Eysenbach, Russ R Salakhutdinov, and Sergey Levine. Search on the replay buffer: Bridging planning and reinforcement learning. In Advances in Neural Information Processing Systems, pp. 15246–15257, 2019. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            546
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gregory Farquhar, Tim Rocktaschel, Maximilian Igl, and Shimon Whiteson. Treeqn and atreec: ¨ Differentiable tree-structured models for deep reinforcement learning. October 2017. URL http://arxiv.org/abs/1710.11417. ",
+        "bbox": [
+            176,
+            554,
+            825,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sabine Gillner and Hanspeter A Mallot. Navigation and acquisition of spatial knowledge in a virtual maze. Journal of cognitive neuroscience, 10(4):445–463, 1998. ",
+        "bbox": [
+            169,
+            606,
+            823,
+            635
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Ha and Jurgen Schmidhuber. Recurrent world models facilitate policy evolution. In ¨ Advances in Neural Information Processing Systems, pp. 2450–2462, 2018. ",
+        "bbox": [
+            169,
+            642,
+            823,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In International Conference on Machine Learning, pp. 2555–2565. PMLR, 2019. ",
+        "bbox": [
+            176,
+            680,
+            825,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danijar Hafner, Timothy Lillicrap, Mohammad Norouzi, and Jimmy Ba. Mastering atari with discrete world models. arXiv preprint arXiv:2010.02193, 2020. ",
+        "bbox": [
+            171,
+            731,
+            823,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter E Hart, Nils J Nilsson, and Bertram Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE transactions on Systems Science and Cybernetics, 4(2):100–107, 1968. ",
+        "bbox": [
+            173,
+            768,
+            823,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhiao Huang, Fangchen Liu, and Hao Su. Mapping state space using landmarks for universal goal reaching. In Advances in Neural Information Processing Systems, pp. 1942–1952, 2019. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Model-based policy optimization. In Advances in Neural Information Processing Systems, pp. 12519–12530, 2019. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom Jurgenson, Or Avner, Edward Groshev, and Aviv Tamar. Sub-goal trees–a framework for goal-based reinforcement learning. arXiv preprint arXiv:2002.12361, 2020. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            174,
+            141,
+            825,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thanard Kurutach, Ignasi Clavera, Yan Duan, Aviv Tamar, and Pieter Abbeel. Model-ensemble trust-region policy optimization. arXiv preprint arXiv:1802.10592, 2018. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            209
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Laskin, Scott Emmons, Ajay Jain, Thanard Kurutach, Pieter Abbeel, and Deepak Pathak. Sparse graphical memory for robust planning. arXiv preprint arXiv:2003.06417, 2020. ",
+        "bbox": [
+            174,
+            218,
+            826,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Steven M LaValle. Rapidly-exploring random trees: A new tool for path planning. 1998. ",
+        "bbox": [
+            173,
+            257,
+            758,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lisa Lee, Emilio Parisotto, Devendra Singh Chaplot, Eric Xing, and Ruslan Salakhutdinov. Gated path planning networks. June 2018. URL http://arxiv.org/abs/1806.06408. ",
+        "bbox": [
+            176,
+            281,
+            821,
+            311
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            174,
+            320,
+            826,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kara Liu, Thanard Kurutach, Christine Kit-Ching Tung, Pieter Abbeel, and Aviv Tamar. Hallucinative topological memory for zero-shot visual planning. ArXiv, 2019. URL https://www.semanticscholar.org/paper/ b8f0417844523d788630bb28a600dfeb74914e2d. ",
+        "bbox": [
+            173,
+            372,
+            826,
+            429
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuping Luo, Huazhe Xu, Yuanzhi Li, Yuandong Tian, Trevor Darrell, and Tengyu Ma. Algorithmic framework for model-based deep reinforcement learning with theoretical guarantees. arXiv preprint arXiv:1807.03858, 2018. ",
+        "bbox": [
+            176,
+            438,
+            823,
+            481
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ofir Nachum, Shixiang Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforcement learning. In Advances in Neural Information Processing Systems, pp. 3303–3313, 2018. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 7559–7566. IEEE, 2018. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashvin V Nair, Vitchyr Pong, Murtaza Dalal, Shikhar Bahl, Steven Lin, and Sergey Levine. Visual reinforcement learning with imagined goals. In Advances in Neural Information Processing Systems, pp. 9191–9200, 2018. ",
+        "bbox": [
+            173,
+            594,
+            826,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Soroush Nasiriany, Vitchyr Pong, Steven Lin, and Sergey Levine. Planning with goal-conditioned policies. In Advances in Neural Information Processing Systems, pp. 14843–14854, 2019. ",
+        "bbox": [
+            171,
+            647,
+            823,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karl Pertsch, Oleh Rybkin, Frederik Ebert, Chelsea Finn, Dinesh Jayaraman, and Sergey Levine. Long-horizon visual planning with goal-conditioned hierarchical predictors. arXiv preprint arXiv:2006.13205, 2020. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Silviu Pitis, Harris Chan, Stephen Zhao, Bradly Stadie, and Jimmy Ba. Maximum entropy gain exploration for long horizon multi-goal reinforcement learning. arXiv preprint arXiv:2007.02832, 2020. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthias Plappert, Marcin Andrychowicz, Alex Ray, Bob McGrew, Bowen Baker, Glenn Powell, Jonas Schneider, Josh Tobin, Maciek Chociej, Peter Welinder, et al. Multi-goal reinforcement learning: Challenging robotics environments and request for research. arXiv preprint arXiv:1802.09464, 2018. ",
+        "bbox": [
+            173,
+            790,
+            826,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vitchyr Pong, Shixiang Gu, Murtaza Dalal, and Sergey Levine. Temporal difference models: Modelfree deep rl for model-based control. arXiv preprint arXiv:1802.09081, 2018. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vitchyr H Pong, Murtaza Dalal, Steven Lin, Ashvin Nair, Shikhar Bahl, and Sergey Levine. Skew-fit: State-covering self-supervised reinforcement learning. arXiv preprint arXiv:1903.03698, 2019. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sebastien Racani ´ ere, Theophane Weber, David Reichert, Lars Buesing, Arthur Guez, Danilo \\` Jimenez Rezende, Adria Puigdom \\` enech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, Razvan Pas- \\` canu, Peter Battaglia, Demis Hassabis, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. In I Guyon, U V Luxburg, S Bengio, H Wallach, R Fergus, S Vishwanathan, and R Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 5690–5701. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 7152-imagination-augmented-agents-for-deep-reinforcement-learning. pdf. ",
+        "bbox": [
+            173,
+            103,
+            838,
+            215
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nikolay Savinov, Alexey Dosovitskiy, and Vladlen Koltun. Semi-parametric topological memory for navigation. arXiv preprint arXiv:1803.00653, 2018a. ",
+        "bbox": [
+            173,
+            224,
+            825,
+            253
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nikolay Savinov, Anton Raichuk, Raphael Marinier, Damien Vincent, Marc Pollefeys, Timothy Lilli- ¨ crap, and Sylvain Gelly. Episodic curiosity through reachability. arXiv preprint arXiv:1810.02274, 2018b. ",
+        "bbox": [
+            173,
+            261,
+            826,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016a. ",
+        "bbox": [
+            176,
+            313,
+            826,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Hado van Hasselt, Matteo Hessel, Tom Schaul, Arthur Guez, Tim Harley, Gabriel DulacArnold, David Reichert, Neil Rabinowitz, Andre Barreto, and Thomas Degris. The predictron: End-to-end learning and planning. December 2016b. URL http://arxiv.org/abs/1612. 08810. ",
+        "bbox": [
+            173,
+            364,
+            826,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aravind Srinivas, Allan Jabri, Pieter Abbeel, Sergey Levine, and Chelsea Finn. Universal planning networks. April 2018. URL http://arxiv.org/abs/1804.00645. ",
+        "bbox": [
+            171,
+            430,
+            825,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton. Dyna, an integrated architecture for learning, planning, and reacting. ACM Sigart Bulletin, 2(4):160–163, 1991. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. February 2016. URL http://arxiv.org/abs/1602.02867. ",
+        "bbox": [
+            171,
+            506,
+            825,
+            535
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg, David Silver, and Koray Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. arXiv preprint arXiv:1703.01161, 2017. ",
+        "bbox": [
+            174,
+            544,
+            826,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ranxiao Frances Wang and Elizabeth S Spelke. Human spatial representation: Insights from animals. Trends in cognitive sciences, 6(9):376–382, 2002. ",
+        "bbox": [
+            173,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tingwu Wang and Jimmy Ba. Exploring model-based planning with policy networks. arXiv preprint arXiv:1906.08649, 2019. ",
+        "bbox": [
+            173,
+            632,
+            823,
+            661
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yang Wang, David Mulvaney, Ian Sillitoe, and Erick Swere. Robot navigation by waypoints. Journal of Intelligent and Robotic Systems, 52(2):175–207, 2008. ",
+        "bbox": [
+            174,
+            670,
+            823,
+            700
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ge Yang, Amy Zhang, Ari S. Morcos, Joelle Pineau, Pieter Abbeel, and Roberto Calandra. Plan2vec: Unsupervised representation learning by latent plans. In Proceedings of The 2nd Annual Conference on Learning for Dynamics and Control, volume 120 of Proceedings of Machine Learning Research, pp. 1–12, 2020. arXiv:2005.03648. ",
+        "bbox": [
+            173,
+            708,
+            826,
+            765
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rui Zhao, Xudong Sun, and Volker Tresp. Maximum entropy-regularized multi-goal reinforcement learning. arXiv preprint arXiv:1905.08786, 2019. ",
+        "bbox": [
+            174,
+            773,
+            823,
+            803
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 GREEDY LATENT SPARSIFICATION ",
+        "bbox": [
+            176,
+            138,
+            455,
+            154
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Greedy Latent Sparsification (GLS) for Latent Cluster Training Given: Replay Buffer $B$ , Encoder $f _ { E }$ .   \nInitialize: LatentEmbeds $= \\{ \\}$ . $\\triangleright$ Set of embeddings selected. 1: Sample $K$ achieved goals from $B$ .   \n2: Sample $k \\sim \\{ 0 \\cdots K - 1 \\}$ .   \n3: dist $= [ \\| f _ { E } ( g _ { 1 } ) - f _ { E } ( \\bar { g } _ { k } ) \\| _ { 2 } ^ { 2 } , \\cdot \\cdot \\cdot , \\| f _ { E } ( g _ { K } ) - f _ { E } ( g _ { k } ) \\| _ { 2 } ^ { 2 } ]$   \n4: for $\\mathrm { i } = 1$ to $M$ do . Sub-sampling 5: $k $ arg max dist $[ k ]$   \n6: Add $f _ { E } ( g _ { k } )$ to LatentEmbeds.   \n7: NEWdist = [kfE(g1) − fE(gk)k22, · · · , kfE(gK ) − fE(gk)k22] 8: dist = ElementwiseMin(dist, NEWdist)   \n9: end for   \n10: Optimize equation 5 on LatentEmbeds. ",
+        "bbox": [
+            174,
+            179,
+            665,
+            372
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The Greedy Latent Sparsification (GLS) algorithm sub-samples a large batch by sparsification. GLS first randomly selects a latent embedding from the batch, and then greedily chooses the next embedding that is furthest away from already selected embeddings. After collecting some warm-up trajectories before planning starts (see Table 2) during training, we first use GLS to initialize the latent centroids, and then continue to use it to sample the batches used to train the latent clusters. As mentioned in Section 4.2, GLS is strongly inspired by Arthur & Vassilvitskii (2007), and this type of approach is known to improve clustering. ",
+        "bbox": [
+            173,
+            386,
+            826,
+            484
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 GRAPH SEARCH VIA SOFT VALUE ITERATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            544,
+            523
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we employ a soft version of Floyd algorithm, which we find to empirically work well. Rather than simply using the min operation to do relaxation, the soft value iteration procedure uses a sof t min operation when doing an update (note that, since we negated the distances to be negative in the weight matrix of the graph, which is Equation 6, the operations we use are actually max and softmax). The reason is that neural distances can be inconsistent and inaccurate at times, and using a soft operation makes the whole procedure more robust. More concretely, we repeat the following update on the weight matrix for $S$ steps with temperature $\\beta$ : ",
+        "bbox": [
+            173,
+            537,
+            825,
+            637
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b7d70f38ee5d00c13b0a2b0d313de740a18e1a875b23c97d2b7e83470261d5e8.jpg",
+        "text": "$$\nw _ { i , j } \\gets \\sum _ { k = 1 } ^ { N + 1 } \\frac { \\exp \\frac { 1 } { \\beta } ( w _ { i , k } + w _ { k , j } ) } { \\sum _ { k ^ { \\prime } = 1 } ^ { N + 1 } \\exp \\frac { 1 } { \\beta } ( w _ { i , k ^ { \\prime } } + w _ { k ^ { \\prime } , j } ) } \\Big ( w _ { i , k } + w _ { k , j } \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            651,
+            687,
+            715
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Following the practice in Eysenbach et al. (2019); Huang et al. (2019), we do the following initialization to the matrix in Equation 6: for entries smaller than the negative of $d _ { - } m a x$ , we penalize the entry by adding $- \\infty$ to it (in this paper, we use $- 1 0 ^ { 6 }$ as the $- \\infty$ value). The essential idea is that we only trust a neural estimate when it is local, and we rely on graph search to solve for global, longer-horizon distances. The $- \\infty$ penalty effectively masks out those entries with large negative values in the softmax operation above. If we replace softmax with a hard max, we recover the original update in Floyd algorithm; we can interpolate between a hard Floyd and a soft Floyd by tuning the temperature $\\beta$ . ",
+        "bbox": [
+            173,
+            728,
+            825,
+            840
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            866,
+            367,
+            880
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 1 lists the common hyper-parameters across all environments. Table 2 lists the hyper-parameters that differ across the environments. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/aac409147f65948a3f1c0a986648e156e0d4179dd97db3eef4b4d17552fe86ae.jpg",
+        "table_caption": [
+            "Table 1: Hyper-parameters in Common "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>Parameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=2 colspan=2>DDPGoptimizernumber of hidden layers (all networks)number of hidden units per layernonlinearitypolyak for target network(T)target update intervalratio between env vs optimization stepsRandom action probabilityInitial random trajs per workerHindsight relabelling ratio</td><td rowspan=2 colspan=1>Adam (Kingma &amp; Ba, 2014)3256ReLU0.9951020.21000.85</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=2>LatentLandmarks&amp;Auto-encodernumber of hidden layersnumber of hidden units per layernonlinearityembedding size入 for reachability constraint losslearning rate</td><td rowspan=1 colspan=1>2128ReLU161.03e-4</td></tr><tr><td rowspan=1 colspan=2>Graph Searchprobability of using search during trainS (number of soft value iterations)β (temperature)</td><td rowspan=1 colspan=1>0.5201.1</td></tr></table>",
+        "bbox": [
+            246,
+            131,
+            751,
+            510
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/271ab8a999cc72db1a1629f2de7f80c6a0e2216b3d10dd8053c44a8681f49b74.jpg",
+        "table_caption": [
+            "Table 2: Hyper-parameters for Each Environment "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">Point-Maze Ant-Maze</td></tr><tr><td colspan=\"4\">DDPG</td></tr><tr><td>Learning rate</td><td>2e-4</td><td>2e-4</td><td>1e-3 12</td></tr><tr><td>Number of workers Batch size</td><td>1 512</td><td>3 1024</td><td>1024</td></tr><tr><td>Action L2</td><td>0.5</td><td>0.05</td><td>0.01</td></tr><tr><td>Gamma</td><td>0.98</td><td>0.98</td><td>0.99</td></tr><tr><td>Action noise</td><td>0.2</td><td>0.2</td><td>0.1</td></tr><tr><td>Hindsight relabelling range</td><td>80</td><td>100</td><td>50</td></tr><tr><td colspan=\"4\">LatentLandmarks&amp;Auto-encoder</td></tr><tr><td>Number of latent landmarks</td><td>50</td><td>50</td><td>80</td></tr><tr><td>Number of warm-up trajectories</td><td>500</td><td>500</td><td>6000</td></tr><tr><td>Batch size</td><td>256</td><td>256</td><td>150</td></tr><tr><td colspan=\"4\">Graph Search</td></tr><tr><td>d_max (clipping threshold for distances)</td><td>20.0</td><td>20.0</td><td>15.0</td></tr><tr><td>Random landmarks added during train</td><td>150</td><td>150</td><td>20</td></tr></table>",
+        "bbox": [
+            215,
+            569,
+            779,
+            840
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "• We find that having a centralized replay for all parallel workers is significantly more sample efficient than having separate replays for each worker and simply averaging the gradients across workers.   \n• For Ant-Maze environment, we do grad norm clipping by a value of 15.0 for all networks. For Fetch tasks, we normalize the inputs by running means and standard deviations per input dimensions.   \n• Since $L ^ { 3 } P$ is able to decompose a long-horizon goal into many short-horizon goals, we shorten the range of future steps where we do hindsight relabelling; as a result, the agent can focus its optimization effort on more immediate goals. This corresponds to the hyperparameter: Hindsight relabelling range.   \n• During training, we collect $5 0 \\%$ of the data without the planning module, and the other $5 0 \\%$ of the data with planning. This corresponds to the hyper-parameter: probability of using search during train.   \n• At train time, to encourage exploration during planning, we temporarily add a small number of random landmarks from GLS (Algorithm 2) to the existing latent landmarks. A new set of random landmarks is selected for each episode before graph search starts (Algorithm 1). This corresponds to the hyper-parameter: Random landmarks added during train.   \n• We find that collecting a certain number of warm-up trajectories for every worker before the planning procedure starts (during training) and before GLS (Algorithm 2) is used for initialization to help improve the planning results. This corresponds to the hyper-parameter: Number of warm-up trajectories. ",
+        "bbox": [
+            215,
+            103,
+            826,
+            420
+        ],
+        "page_idx": 14
+    }
+]

parse/train/H1Dy---0Z/H1Dy---0Z_content_list.json

@@ -0,0 +1,1771 @@
+[
+    {
+        "type": "text",
+        "text": "DISTRIBUTED PRIORITIZED EXPERIENCE REPLAY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            772,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dan Horgan   \nDeepMind   \nhorgan@google.com   \nJohn Quan   \nDeepMind   \njohnquan@google.com   \nDavid Budden   \nDeepMind   \nbudden@google.com ",
+        "bbox": [
+            183,
+            145,
+            352,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            403,
+            145,
+            594,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            643,
+            145,
+            813,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Barth-Maron DeepMind gabrielbm@google.com ",
+        "bbox": [
+            183,
+            208,
+            383,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Matteo Hessel   \nDeepMind   \nmtthss@google.com ",
+        "bbox": [
+            437,
+            208,
+            607,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt DeepMind hado@google.com ",
+        "bbox": [
+            663,
+            208,
+            813,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Silver   \nDeepMind   \ndavidsilver@google.com ",
+        "bbox": [
+            184,
+            271,
+            401,
+            313
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            349,
+            544,
+            364
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a distributed architecture for deep reinforcement learning at scale, that enables agents to learn effectively from orders of magnitude more data than previously possible. The algorithm decouples acting from learning: the actors interact with their own instances of the environment by selecting actions according to a shared neural network, and accumulate the resulting experience in a shared experience replay memory; the learner replays samples of experience and updates the neural network. The architecture relies on prioritized experience replay to focus only on the most significant data generated by the actors. Our architecture substantially improves the state of the art on the Arcade Learning Environment, achieving better final performance in a fraction of the wall-clock training time. ",
+        "bbox": [
+            233,
+            386,
+            764,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            560,
+            336,
+            577
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A broad trend in deep learning is that combining more computation (Dean et al., 2012) with more powerful models (Kaiser et al., 2017) and larger datasets (Deng et al., 2009) yields more impressive results. It is reasonable to hope that a similar principle holds for deep reinforcement learning. There are a growing number of examples to justify this optimism: effective use of greater computational resources has been a critical factor in the success of such algorithms as Gorila (Nair et al., 2015), A3C (Mnih et al., 2016), GPU Advantage Actor Critic (Babaeizadeh et al., 2017), Distributed PPO (Heess et al., 2017) and AlphaGo (Silver et al., 2016). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning frameworks such as TensorFlow (Abadi et al., 2016) support distributed training, making large scale machine learning systems easier to implement and deploy. Despite this, much current research in deep reinforcement learning concerns itself with improving performance within the computational budget of a single machine, and the question of how to best harness more resources is comparatively underexplored. ",
+        "bbox": [
+            174,
+            700,
+            823,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we describe an approach to scaling up deep reinforcement learning by generating more data and selecting from it in a prioritized fashion (Schaul et al., 2016). Standard approaches to distributed training of neural networks focus on parallelizing the computation of gradients, to more rapidly optimize the parameters (Dean et al., 2012). In contrast, we distribute the generation and selection of experience data, and find that this alone suffices to improve results. This is complementary to distributing gradient computation, and the two approaches can be combined, but in this work we focus purely on data-generation. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We use this distributed architecture to scale up variants of Deep Q-Networks (DQN) and Deep Deterministic Policy Gradient (DDPG), and we evaluate these on the Arcade Learning Environment benchmark (Bellemare et al., 2013), and on a range of continuous control tasks. Our architecture achieves a new state of the art performance on Atari games, using a fraction of the wall-clock time compared to the previous state of the art, and without per-game hyperparameter tuning. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We empirically investigate the scalability of our framework, analysing how prioritization affects performance as we increase the number of data-generating workers. Our experiments include an analysis of factors such as the replay capacity, the recency of the experience, and the use of different data-generating policies for different workers. Finally, we discuss implications for deep reinforcement learning agents that may apply beyond our distributed framework. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            208
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            233,
+            326,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distributed Stochastic Gradient Descent Distributed stochastic gradient descent is widely used in supervised learning to speed up training of deep neural networks, by parallelizing the computation of the gradients used to update their parameters. The resulting parameter updates may be applied synchronously (Krizhevsky, 2014) or asynchronously (Dean et al., 2012). Both approaches have proven effective and are an increasingly standard part of the deep learning toolbox. Inspired by this, Nair et al. (2015) applied distributed asynchronous parameter updates and distributed data generation to deep reinforcement learning. Asynchronous parameter updates and parallel data generation have also been successfully used within a single-machine, in a multi-threaded rather than a distributed context (Mnih et al., 2016). GPU Asynchronous Actor-Critic (GA3C; Babaeizadeh et al., 2017) and Parallel Advantage Actor-Critic (PAAC; Clemente et al., 2017) adapt this approach to make efficient use of GPUs. ",
+        "bbox": [
+            173,
+            267,
+            825,
+            420
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distributed Importance Sampling A complementary family of techniques for speeding up training is based on variance reduction by means of importance sampling (cf. Hastings, 1970). This has been shown to be useful in the context of neural networks (Hinton, 2007). Sampling non-uniformly from a dataset and weighting updates according to the sampling probability in order to counteract the bias thereby introduced can increase the speed of convergence by reducing the variance of the gradients. One way of doing this is to select samples with probability proportional to the $L _ { 2 }$ norm of the corresponding gradients. In supervised learning, this approach has been successfully extended to the distributed setting (Alain et al., 2015). An alternative is to rank samples according to their latest known loss value and make the sampling probability a function of the rank rather than of the loss itself (Loshchilov & Hutter, 2015). ",
+        "bbox": [
+            174,
+            440,
+            825,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Prioritized Experience Replay Experience replay (Lin, 1992) has long been used in reinforcement learning to improve data efficiency. It is particularly useful when training neural network function approximators with stochastic gradient descent algorithms, as in Neural Fitted Q-Iteration (Riedmiller, 2005) and Deep Q-Learning (Mnih et al., 2015). Experience replay may also help to prevent overfitting by allowing the agent to learn from data generated by previous versions of the policy. Prioritized experience replay (Schaul et al., 2016) extends classic prioritized sweeping ideas (Moore & Atkeson, 1993) to work with deep neural network function approximators. The approach is strongly related to the importance sampling techniques discussed in the previous section, but using a more general class of biased sampling procedures that focus learning on the most ‘surprising’ experiences. Biased sampling can be particularly helpful in reinforcement learning, since the reward signal may be sparse and the data distribution depends on the agent’s policy. As a result, prioritized experience replay is used in many agents, such as Prioritized Dueling DQN (Wang et al., 2016), UNREAL (Jaderberg et al., 2017), DQfD (Hester et al., 2017), and Rainbow (Hessel et al., 2017). In an ablation study conducted to investigate the relative importance of several algorithmic ingredients (Hessel et al., 2017), prioritization was found to be the most important ingredient contributing to the agent’s performance. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 OUR CONTRIBUTION: DISTRIBUTED PRIORITIZED EXPERIENCE REPLAY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            847,
+            805,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper we extend prioritized experience replay to the distributed setting and show that this is a highly scalable approach to deep reinforcement learning. We introduce a few key modifications that enable this scalability, and we refer to our approach as Ape-X. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/296c1e633a240d666b61e3fc734c73d9f50a0a7d3b02cdc0f15e8a24a2000039.jpg",
+        "image_caption": [
+            "Figure 1: The Ape-X architecture in a nutshell: multiple actors, each with its own instance of the environment, generate experience, add it to a shared experience replay memory, and compute initial priorities for the data. The (single) learner samples from this memory and updates the network and the priorities of the experience in the memory. The actors’ networks are periodically updated with the latest network parameters from the learner. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            818,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/1fbea80e659083b7a2310268db5650bd3ffafb3a2b4a2a82e26cd21b77044233.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm1 Actor</td><td></td></tr><tr><td colspan=\"2\">1: procedure ACTOR(B,T)</td><td>&gt;Run agent in environment instance,storing experiences.</td></tr><tr><td>2:</td><td>00←LEARNER.PARAMETERS()</td><td>Remote call to obtain latest network parameters.</td></tr><tr><td>3:</td><td>SO←ENVIRONMENT.INITIALIZE()</td><td>&gt;Get initial state from environment.</td></tr><tr><td>4:</td><td>fort=1toTdo</td><td></td></tr><tr><td>5:</td><td>at-1←π0t-1(St-1)</td><td> Select an action using the current policy.</td></tr><tr><td>6:</td><td>(Tt,t,St） ←ENVIRONMENT.STEP(at-1)</td><td>&gt;Apply the action in the environment.</td></tr><tr><td>7:</td><td>LOCALBUFFER.ADD((St-1,at-1,rt,/t))</td><td>Add data to local buffer.</td></tr><tr><td>8:</td><td></td><td>if LOCALBUFFER.SIzE(）≥ B thenIn a background thread, periodically send data to replay.</td></tr><tr><td>9:</td><td>T ←LOCALBUFFER.GET(B)</td><td>Get buffered data (e.g.batch of multi-step transitions).</td></tr><tr><td>10:</td><td></td><td>p ← COMPUTEPRIORITIEs(T）&gt;Calculate priorities for experience (e.g.absolute TD error).</td></tr><tr><td>11:</td><td>REPLAY.ADD(T,p)</td><td>&gt;Remote call to add experience to replay memory.</td></tr><tr><td>12:</td><td>endif</td><td></td></tr><tr><td>13:</td><td>PERIODICALLY(0t ← LEARNER.PARAMETERS())</td><td> Obtain latest network parameters.</td></tr><tr><td>14:</td><td>end for</td><td></td></tr><tr><td>15: end procedure</td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            347,
+            825,
+            558
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Learner ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            315,
+            595
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: procedure LEARNER $( T )$ . Update network using batches sampled from memory.   \n2: 3: $\\theta _ { 0 } \\gets$ INITIALIZENETWORK( )   \nfor $t = 1$ to $T$ do . Update the parameters $T$ times.   \n4: id, τ ← REPLAY.SAMPLE( ) . Sample a prioritized batch of transitions (in a background thread).   \n5: lt ← COMPUTELOSS $( \\tau ; \\theta _ { t } )$ . Apply learning rule; e.g. double Q-learning or DDPG   \n6: $\\theta _ { t + 1 } \\gets$ UPDATEPARAMETERS $\\left( l _ { t } ; \\theta _ { t } \\right)$   \n7: $p $ COMPUTEPRIORITIES( ) $\\triangleright$ Calculate priorities for experience, (e.g. absolute TD error).   \n8: REPLAY.SETPRIORITY $( i d , p )$ $\\triangleright$ Remote call to update priorities.   \n9: PERIODICALLY(REPLAY.REMOVETOFIT()) . Remove old experience from replay memory.   \n10: end for   \n11: end procedure ",
+        "bbox": [
+            176,
+            598,
+            825,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As in Gorila (Nair et al., 2015), we decompose the standard deep reinforcement learning algorithm into two parts, which run concurrently with no high-level synchronization. The first part consists of stepping through an environment, evaluating a policy implemented as a deep neural network, and storing the observed data in a replay memory. We refer to this as acting. The second part consists of sampling batches of data from the memory to update the policy parameters. We term this learning. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In principle, both acting and learning may be distributed across multiple workers. In our experiments, hundreds of actors run on CPUs to generate data, and a single learner running on a GPU samples the most useful experiences (Figure 1). Pseudocode for the actors and learners is shown in Algorithms 1 and 2. Updated network parameters are periodically communicated to the actors from the learner. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In contrast to Nair et al. (2015), we use a shared, centralized replay memory, and instead of sampling uniformly, we prioritize, to sample the most useful data more often. Since priorities are shared, high priority data discovered by any actor can benefit the whole system. Priorities can be defined in various ways, depending on the learning algorithm; two instances are described in the next sections. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Prioritized DQN (Schaul et al., 2016) priorities for new transitions were initialized to the maximum priority seen so far, and only updated once they were sampled. This does not scale well: due to the large number of actors in our architecture, waiting for the learner to update priorities would result in a myopic focus on the most recent data, which has maximum priority by construction. Instead, we take advantage of the computation the actors in Ape-X are already doing to evaluate their local copies of the policy, by making them also compute suitable priorities for new transitions online. This ensures that data entering the replay has more accurate priorities, at no extra cost. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sharing experiences has certain advantages compared to sharing gradients. Low latency communication is not as important as in distributed SGD, because experience data becomes outdated less rapidly than gradients, provided the learning algorithm is robust to off-policy data. Across the system, we take advantage of this by batching all communications with the centralized replay, increasing the efficiency and throughput at the cost of some latency. With this approach it is even possible for actors and learners to run in different data-centers without limiting performance. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, by learning off-policy (cf. Sutton & Barto, 1998; 2017), we can further take advantage of Ape-X’s ability to combine data from many distributed actors, by giving the different actors different exploration policies, broadening the diversity of the experience they jointly encounter. As we will see in the results, this can be sufficient to make progress on difficult exploration problems. ",
+        "bbox": [
+            176,
+            361,
+            825,
+            417
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 APE-X DQN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            303,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The general framework we have described may be combined with different learning algorithms. First, we combined it with a variant of DQN (Mnih et al., 2015) with some of the components of Rainbow (Hessel et al., 2017). More specifically, we used double Q-learning (van Hasselt, 2010; van Hasselt et al., 2016) with multi-step bootstrap targets (cf. Sutton, 1988; Sutton & Barto, 1998; 2017; Mnih et al., 2016) as the learning algorithm, and a dueling network architecture (Wang et al., 2016) as the function approximator $q ( \\cdot , \\cdot , \\pmb \\theta )$ . ",
+        "bbox": [
+            174,
+            464,
+            825,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This results in computing for all elements in the batch the loss $l _ { t } ( \\pmb \\theta ) = { \\textstyle { \\frac { 1 } { 2 } } } ( G _ { t } - q ( S _ { t } , A _ { t } , \\pmb \\theta ) ) ^ { 2 }$ with ",
+        "bbox": [
+            173,
+            554,
+            820,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d4352f2111e184da03c13bf43134f1c2c2d59a034475ac8a3a1ab43b2cbc37f.jpg",
+        "text": "$$\nG _ { t } = R _ { t + 1 } + \\gamma R _ { t + 2 } + . . . + \\gamma ^ { n - 1 } R _ { t + n } + \\gamma ^ { n } \\overbrace { q ( S _ { t + n } , \\underset { a } { \\mathrm { a r g m a x } } q ( S _ { t + n } , a , \\pmb { \\theta } ) , \\pmb { \\theta } ^ { - } ) } ^ { \\theta _ { t } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            597,
+            771,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $t$ is a time index for an experience sampled from the replay starting with state $S _ { t }$ and action $A _ { t }$ , and $\\pmb { \\theta } ^ { - }$ denotes parameters of the target network (Mnih et al., 2015), a slow moving copy of the online parameters. Multi-step returns are truncated if the episode ends in fewer than $n$ steps. ",
+        "bbox": [
+            176,
+            660,
+            821,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In principle, Q-learning variants are off-policy methods, so we are free to choose the policies we use to generate data. However, in practice, the choice of behaviour policy does affect both exploration and the quality of function approximation. Furthermore, we are using a multi-step return with no off-policy correction, which in theory could adversely affect the value estimation. Nonetheless, in Ape-X DQN, each actor executes a different policy, and this allows experience to be generated from a variety of strategies, relying on the prioritization mechanism to pick out the most effective experiences. In our experiments, the actors use $\\epsilon$ -greedy policies with different values of \u000f. Low $\\epsilon$ policies allow exploring deeper in the environment, while high $\\epsilon$ policies prevent over-specialization. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 APE-X DPG ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            839,
+            302,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To test the generality of the framework we also combined it with a continuous-action policy gradient system based on DDPG (Lillicrap et al., 2016), an implementation of deterministic policy gradients Silver et al. (2014) also similar to older methods (Werbos, 1990; Prokhorov & Wunsch, 1997), and tested it on continuous control tasks from the DeepMind Control Suite (Tassa et al., 2018). ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/522d2edd9c1b2d67e294514c8332509ee6fc49bc75262a06389c9efd7a658ef4.jpg",
+        "image_caption": [
+            "Figure 2: Left: Atari results aggregated across 57 games, evaluated from random no-op starts. Right: Atari training curves for selected games, against baselines. Blue: Ape- $\\mathrm { . } \\mathrm { X }$ DQN with 360 actors; Orange: A3C; Purple: Rainbow; Green: DQN. See appendix for longer runs over all games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            107,
+            815,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Ape-X DPG setup is similar to Ape-X DQN, but the actor’s policy is now represented explicitly by a separate policy network, in addition to the Q-network. The two networks are optimized separately, by minimizing different losses on the sampled experience. We denote the policy and Q-network parameters by $\\phi$ and $\\psi$ respectively, and adopt the same convention as above to denote target networks. The Q-network outputs an action-value estimate $q ( s , a , \\psi )$ for a given state $s$ , and multi-dimensional action $a \\in \\mathbb { R } ^ { m }$ . It is updated using temporal-difference learning with a multi-step bootstrap target. The Q-network loss can be written as $\\begin{array} { r } { l _ { t } ( \\dot { \\psi } ) = \\frac { 1 } { 2 } ( G _ { t } - q ( S _ { t } , A _ { t } , \\hat { \\psi } ) ) ^ { 2 } } \\end{array}$ , where ",
+        "bbox": [
+            173,
+            446,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/addc4d724e646ff2ba1676194b242f9e1d9597276691fb18db172a444559765e.jpg",
+        "text": "$$\nG _ { t } = { R } _ { t + 1 } + \\gamma { R } _ { t + 2 } + \\ldots + \\gamma ^ { n - 1 } { R } _ { t + n } + \\gamma ^ { n } q ( S _ { t + n } , \\pi ( S _ { t + n } , \\phi ^ { - } ) , \\psi ^ { - } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            556,
+            745,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The policy network outputs an action $A _ { t } = \\pi ( S _ { t } , \\phi ) \\in \\mathbb { R } ^ { m }$ . The policy parameters are updated using policy gradient ascent on the estimated Q-value, using gradient $\\nabla _ { \\phi } q ( S _ { t } , \\pi ( S _ { t } , \\phi ) , \\psi )$ — note that this depends on the policy parameters $\\phi$ only through the action $A _ { t } = \\pi ( S _ { t } , \\phi )$ that is input to the critic network. Further details of the Ape- $\\mathbf { \\nabla } \\cdot \\mathbf { X }$ DPG algorithm are available in the appendix. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            671
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            326,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 ATARI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            729,
+            258,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our first set of experiments we evaluate Ape-X DQN on Atari, and show state of the art results on this standard reinforcement learning benchmark. We use 360 actor machines (each using one CPU core) to feed data into the replay memory as fast as they can generate it; approximately 139 frames per second (FPS) each, for a total of $\\mathord { \\sim } 5 0 \\mathrm { K }$ FPS, which corresponds to ${ \\sim } 1 2 . 5 \\mathrm { K }$ transitions (because of a fixed action repeat of 4). The actors batch experience data locally before sending it to the replay: up to 100 transitions may be buffered at a time, which are then sent asynchronously in batches of $B = 5 0$ . The learner asynchronously prefetches up to 16 batches of 512 transitions, and computes updates for 19 such batches each second, meaning that gradients are computed for ${ \\sim } 9 . 7 \\mathrm { K }$ transitions per second on average. To reduce memory and bandwidth requirements, observation data is compressed using a PNG codec when sent and when stored in the replay. The learner decompresses data as it prefetches it, in parallel with computing and applying gradients. The learner also asynchronously handles any requests for parameters from actors. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/40f1840dc0d35f804786bb872484bc93a55c804b0d2624bacdf3bb4d4666646e.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Median normalized scores across 57 Atari games. a Tesla P100. $^ \\mathrm { b } > 1 0 0$ CPUs, with a mixed number of cores per CPU machine. c Only evaluated on 49 games. d Hyper-parameters were tuned per game. "
+        ],
+        "table_body": "<table><tr><td></td><td>Training Time</td><td>Environment Frames</td><td>Resources (per game)</td><td>Median (no-op starts)</td><td>Median (human starts)</td></tr><tr><td>Ape-X DQN</td><td>5 days</td><td>22800M</td><td>376 cores,1 GPU a</td><td>434%</td><td>358%</td></tr><tr><td>Rainbow</td><td>10 days</td><td>200M</td><td>1 GPU</td><td>223%</td><td>153%</td></tr><tr><td>Distributional (C51)</td><td>10 days</td><td>200M</td><td>1 GPU</td><td>178%</td><td>125%</td></tr><tr><td>A3C</td><td>4 days</td><td></td><td>16 cores</td><td></td><td>117%</td></tr><tr><td>Prioritized Dueling</td><td>9.5 days</td><td>200M</td><td>1 GPU</td><td>172%</td><td>115%</td></tr><tr><td>DQN</td><td>9.5 days</td><td>200M</td><td>1 GPU</td><td>79%</td><td>68%</td></tr><tr><td>GorilaDQN</td><td>~4 days</td><td></td><td>unknown b</td><td>96%</td><td>78%</td></tr><tr><td>UNREAL d</td><td></td><td>250M</td><td>16 cores</td><td>331% d</td><td>250% d</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            818,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Actors copy the network parameters from the learner every 400 frames ${ \\sim } 2 . 8$ seconds). Each actor $i \\in \\{ 0 , . . . , N - 1 \\}$ executes an $\\epsilon _ { i }$ -greedy policy where $\\epsilon _ { i } = \\epsilon ^ { 1 + \\frac { i } { N - 1 } \\alpha }$ with $\\epsilon = 0 . 4$ , $\\alpha = 7$ . Each $\\epsilon _ { i }$ is held constant throughout training. The episode length is limited to 50000 frames during training. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The capacity of the shared experience replay memory is soft-limited to 2 million transitions: adding new data is always permitted, to not slow down the actors, but every 100 learning steps any excess data above this capacity threshold is removed en masse, in FIFO order. The median actual size of the memory is 2035050. Data is sampled according to proportional prioritization, with a priority exponent of 0.6 and an importance sampling exponent set to 0.4. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2, on the left, we compare the median human normalized score across all 57 games to several baselines: DQN, Prioritized DQN, Distributional DQN (Bellemare et al., 2017), Rainbow, and Gorila. In all cases the performance is measured at the end of training under the no-op starts testing regime (Mnih et al., 2015). On the right, we show initial learning curves (taken from the greediest actor) for a selection of 6 games (full learning curves for all games are in the appendix). Given that Ape-X can harness substantially more computation than most baselines, one might expect it to train faster. Figure 2 shows that this was indeed the case. Perhaps more surprisingly, our agent achieved a substantially higher final performance. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Table 1 we compare the median human-normalized performance of Ape-X DQN on the Atari benchmark to corresponding metrics as reported for other baseline agents in their respective publications. Whenever available we report results both for no-op starts and for human starts. The human-starts regime (Nair et al., 2015) corresponds to a more challenging generalization test, as the agent is initialized from random starts drawn from games played by human experts. Ape-X’s performance is higher than the performance of any of the baselines according to both metrics. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 CONTINUOUS CONTROL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            382,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In a second set of experiments we evaluated Ape-X DPG on four continuous control tasks. In the manipulator domain the agent must learn to bring a ball to a specified location. In the humanoid domain the agent must learn to control a humanoid body to solve three distinct tasks of increasing complexity: Standing, Walking and Running. Since here we learn from features, rather than from pixels, the observation space is much smaller than it is in the Atari domain. We therefore use small, fully-connected networks (details in the appendix). With 64 actors on this domain, we obtain ${ \\sim } 1 4 \\mathrm { K }$ total FPS (the same number of transitions per second; here we do not use action repeats). We process 86 batches of 256 transitions per second, or ${ \\sim } 2 2 \\mathrm { K }$ transitions processed per second. ",
+        "bbox": [
+            174,
+            720,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows that Ape-X DPG achieved very good performance on all four tasks. The figure shows the performance of Ape-X DPG for different numbers of actors: as the number of actors increases our agent becomes increasingly effective at solving these problems rapidly and reliably, outperforming a standard DDPG baseline trained for over 10 times longer. A parallel paper (Barth-Maron et al., 2018) builds on this work by combining Ape-X DPG with distributional value functions, and the resulting algorithm is successfully applied to further continuous control tasks. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/68ac2839e7130c15b37d2ddc83d85c060709979d5ee6ab32e49a86a218c53bf2.jpg",
+        "image_caption": [
+            "Figure 3: Performance of Ape-X DPG on four continuous control tasks, as a function of wall clock time. Performance improves as we increase the numbers of actors. The black dashed line indicates the maximum performance reached by a standard DDPG baseline over 5 days of training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            102,
+            758,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/51de9b777bf4bcb67084bd1c9e9dcd575aea7ee02b6e8d7faff2298d5f2a16d5.jpg",
+        "image_caption": [
+            "Figure 4: Scaling the number of actors. Performance consistently improves as we scale the number of actors from 8 to 256, note that the number of learning updates performed does not depend on the number of actors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            361,
+            767,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            612,
+            290,
+            627
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we describe additional Ape-X DQN experiments on Atari that helped improve our understanding of the framework, and we investigate the contribution of different components. ",
+        "bbox": [
+            174,
+            645,
+            823,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we investigated how the performance scales with the number of actors. We trained our agent with different numbers of actors (8, 16, 32, 64, 128 and 256) for 35 hours on a subset of 6 Atari games. In all experiments we kept the size of the shared experience replay memory fixed at 1 million transitions. Figure 4 shows that the performance consistently improved as the number of actors increased. The appendix contains learning curves for additional games, and a comparison of the scalability of the algorithm with and without prioritized replay. It is perhaps surprising that performance improved so substantially purely by increasing the number of actors, without changing the rate at which the network parameters are updated, the structure of the network, or the update rule. We hypothesize that the proposed architecture helps with a common deep reinforcement learning failure mode, in which the policy discovered is a local optimum in the parameter space, but not a global one, e.g., due to insufficient exploration. Using a large number of actors with varying amounts of exploration helps to discover promising new courses of action, and prioritized replay ensures that when this happens, the learning algorithm focuses its efforts on this important information. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we investigated varying the capacity of the replay memory (see Figure 5). We used a setup with 256 actors, for a median of ${ \\sim } 3 7 \\mathrm { K }$ total environment frames per second (approximately ${ \\sim } 9 \\mathrm { K }$ transitions). With such a large number of actors, the contents of the memory is replaced much faster than in most DQN-like agents. We observed a small benefit to using a larger replay capacity. We hypothesize this is due to the value of keeping some high priority experiences around for longer and replaying them. As above, a single learner machine trained the network with median 19 batches per second, each of 512 transitions, for a median of ${ \\sim } 9 . 7 \\mathrm { K }$ transitions processed per second. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/69f03644849ff9359e2578d49582786ac8806e7d2c50b0cd6b2216fdc48e3eac.jpg",
+        "image_caption": [
+            "Figure 5: Varying the capacity of the replay. Agents with larger replay memories perform better on most games. Each curve corresponds to a single run, smoothed over 20 points. The curve for Wizard Of Wor with replay size 250K is incomplete because training diverged; we did not observe this with the other replay sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            104,
+            812,
+            344
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            404,
+            821,
+            445
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we ran additional experiments to disentangle potential effects of two confounding factors in our scalability analysis: recency of the experience data in the replay memory, and diversity of the data-generating policies. The full description of these experiments is confined to the appendix; to summarize, neither factor alone is sufficient to explain the performance we see. We therefore conclude that the results are due substantially to the positive effects of gathering more experience data; namely better exploration of the environment and better avoidance of overfitting. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            318,
+            573
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have designed, implemented, and analyzed a distributed framework for prioritized replay in deep reinforcement learning. This architecture achieved state of the art results in a wide range of discrete and continuous tasks, both in terms of wall-clock learning speed and final performance. ",
+        "bbox": [
+            176,
+            588,
+            825,
+            631
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper we focused on applying the Ape-X framework to DQN and DPG, but it could also be combined with any other off-policy reinforcement learning update. For methods that use temporally extended sequences (e.g., Mnih et al., 2016; Wang et al., 2017), the Ape-X framework may be adapted to prioritize sequences of past experiences instead of individual transitions. ",
+        "bbox": [
+            176,
+            637,
+            825,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ape-X is designed for regimes in which it is possible to generate large quantities of data in parallel. This includes simulated environments but also a variety of real-world applications, such as robotic arm farms, self-driving cars, online recommender systems, or other multi-user systems in which data is generated by many instances of the same environment (c.f. Silver et al., 2013). In applications where data is costly to obtain, our approach will not be directly applicable. With powerful function approximators, overfitting is an issue: generating more training data is the simplest way of addressing it, but may also provide guidance towards data-efficient solutions. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Many deep reinforcement learning algorithms are fundamentally limited by their ability to explore effectively in large domains. Ape-X uses a naive yet effective mechanism to address this issue: generating a diverse set of experiences and then identifying and learning from the most useful events. The success of this approach suggests that simple and direct approaches to exploration may be feasible, even for synchronous agents. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our architecture illustrates that distributed systems are now practical both for research and, potentially, large-scale applications of deep reinforcement learning. We hope that the algorithms, architecture, and analysis we have presented will help to accelerate future efforts in this direction. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to acknowledge the contributions of our colleagues at DeepMind, whose input and support has been vital to the success of this work. Thanks in particular to Tom Schaul, Joseph Modayil, Sriram Srinivasan, Georg Ostrovski, Josh Abramson, Todd Hester, Jean-Baptiste Lespiau, Alban Rrustemi and Dan Belov. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            184
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            287,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016. ",
+        "bbox": [
+            176,
+            227,
+            823,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Alain, Alex Lamb, Chinnadhurai Sankar, Aaron Courville, and Yoshua Bengio. Variance reduction in sgd by distributed importance sampling. arXiv preprint arXiv:1511.06481, 2015. ",
+        "bbox": [
+            171,
+            277,
+            823,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Babaeizadeh, Iuri Frosio, Stephen Tyree, Jason Clemons, and Jan Kautz. Reinforcement learning through asynchronous advantage actor-critic on a gpu. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            314,
+            823,
+            357
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Barth-Maron, Matthew W. Hoffman, David Budden, Will Dabney, Dan Horgan, Dhruva TB, Alistair Muldal, Nicolas Heess, and Timothy Lillicrap. Distributional policy gradients. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            176,
+            364,
+            825,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res. (JAIR), 47:253–279, 2013. ",
+        "bbox": [
+            176,
+            415,
+            823,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc G. Bellemare, Will Dabney, and Remi Munos. A distributional perspective on reinforcement ´ learning. In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            169,
+            465,
+            823,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alfredo V. Clemente, Humberto Nicolas Castej ´ on Mart ´ ´ınez, and Arjun Chandra. Efficient parallel methods for deep reinforcement learning. arXiv preprint arXiv:1705.04862, 2017. ",
+        "bbox": [
+            171,
+            502,
+            823,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Dean, Greg S. Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Quoc V. Le, Mark Z. Mao, Marc’Aurelio Ranzato, Andrew Senior, Paul Tucker, Ke Yang, and Andrew Y. Ng. Large scale distributed deep networks. In Proceedings of the 25th International Conference on Neural Information Processing Systems, NIPS’12, pp. 1223–1231, USA, 2012. Curran Associates Inc. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            597
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            633
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "W Keith Hastings. Monte carlo sampling methods using markov chains and their applications. Biometrika, 57(1):97–109, 1970. ",
+        "bbox": [
+            171,
+            641,
+            821,
+            670
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Dhruva TB, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, S. M. Ali Eslami, Martin A. Riedmiller, and David Silver. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matteo Hessel, Joseph Modayil, Hado van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. arXiv preprint arXiv:1710.02298, 2017. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Andrew Sendonaris, Gabriel Dulac-Arnold, Ian Osband, John Agapiou, Joel Z. Leibo, and Audrunas Gruslys. Learning from demonstrations for real world reinforcement learning. CoRR, abs/1704.03732, 2017. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton. To recognize shapes, first learn to generate images. Prog. Brain Res., 165: 535–547, 2007. ",
+        "bbox": [
+            173,
+            844,
+            820,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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 Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lukasz Kaiser, Aidan N. Gomez, Noam Shazeer, Ashish Vaswani, Niki Parmar, Llion Jones, and Jakob Uszkoreit. One model to learn them all. CoRR, abs/1706.05137, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv preprint arXiv:1404.5997, 2014. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. In International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            173,
+            217,
+            823,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Long-H Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine Learning, 1992. ",
+        "bbox": [
+            171,
+            270,
+            821,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Online batch selection for faster training of neural networks. arXiv preprint arXiv:1511.06343, 2015. ",
+        "bbox": [
+            171,
+            308,
+            820,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "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, 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, 518(7540):529–533, 26 February 2015. ",
+        "bbox": [
+            173,
+            345,
+            825,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 11 June 2016. ",
+        "bbox": [
+            176,
+            426,
+            823,
+            469
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew W Moore and Christopher G Atkeson. Prioritized sweeping: Reinforcement learning with less data and less time. Machine learning, 13(1):103–130, 1993. ",
+        "bbox": [
+            169,
+            478,
+            823,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, Shane Legg, Volodymyr Mnih, Koray Kavukcuoglu, and David Silver. Massively parallel methods for deep reinforcement learning. arXiv preprint arXiv:1507.04296, 15 July 2015. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            573
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danil V Prokhorov and Donald C Wunsch. Adaptive critic designs. IEEE transactions on Neural Networks, 8(5):997–1007, 1997. ",
+        "bbox": [
+            174,
+            582,
+            821,
+            612
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Riedmiller. Neural Fitted Q Iteration – First Experiences with a Data Efficient Neural Reinforcement Learning Method, pp. 317–328. Springer Berlin Heidelberg, Berlin, Heidelberg, 2005. ISBN 978-3-540-31692-3. doi: 10.1007/11564096 32. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. In International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            173,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Leonard Newnham, David Barker, Suzanne Weller, and Jason McFall. Concurrent reinforcement learning from customer interactions. In Sanjoy Dasgupta and David McAllester (eds.), Proceedings of the 30th International Conference on Machine Learning, volume 28 of Proceedings of Machine Learning Research, pp. 924–932, Atlanta, Georgia, USA, 17–19 Jun 2013. PMLR. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 387–395, 2014. ",
+        "bbox": [
+            176,
+            790,
+            825,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton. Learning to predict by the methods of temporal differences. Machine learning, 3 (1):9–44, 1988. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press Cambridge, 1998. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, 2nd edition. 2017. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy Lillicrap, and Martin Riedmiller. Deepmind control suite, 2018. ",
+        "bbox": [
+            178,
+            165,
+            821,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            174,
+            215,
+            823,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "George E Uhlenbeck and Leonard S Ornstein. On the theory of the brownian motion. Physical review, 36(5):823, 1930. ",
+        "bbox": [
+            173,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt. Double Q-learning. In Advances in Neural Information Processing Systems, pp. 2613–2621, 2010. ",
+        "bbox": [
+            174,
+            305,
+            823,
+            334
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Qlearning. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            171,
+            343,
+            821,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Tom Schaul, Matteo Hessel, Hado van Hasselt, Marc Lanctot, and Nando de Freitas. Dueling network architectures for deep reinforcement learning. In International Conference on Machine Learning, 2016. ",
+        "bbox": [
+            173,
+            381,
+            823,
+            424
+        ],
+        "page_idx": 10
+    },
+    {
+        "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. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            173,
+            433,
+            825,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paul J Werbos. A menu of designs for reinforcement learning over time. Neural networks for control, pp. 67–95, 1990. ",
+        "bbox": [
+            173,
+            484,
+            823,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b3b79c13d26d6fed6dca4023299993f982f83e79bbd8e54b2086089ae920475.jpg",
+        "image_caption": [
+            "Figure 6: Testing whether improved performance is caused by recency alone: $n$ denotes the number of actors, $k$ the number of times each transition is replicated in the replay. The data in the run with $n = 3 2$ , $k = 8$ is therefore as recent as the data in the run with $n = 2 5 6$ , $k = 1$ , but performance is not as good. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            118,
+            480,
+            357
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/c909664ab5ef543ed7ca2eb3429fdfb0d4b073de41ff640549f61dc8e9cb52a7.jpg",
+        "image_caption": [
+            "Figure 7: Varying the data-generating policies: Red: fixed set of 6 values for $\\cdot$ . Blue: full range of values for $\\epsilon$ . In both cases, the curve plotted is from a separate actor that does not add data to the replay memory, and which follows an $\\epsilon$ -greedy policy with $\\epsilon = 0 . 0 0 1 6 4$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            516,
+            127,
+            813,
+            354
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A RECENCY OF EXPERIENCE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            454,
+            431,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In our main experiments we do not change the size of the replay memory in proportion to the number of actors, so by changing the number of actors we also increased the rate at which the contents of the replay memory is replaced. This means that in the experiments with more actors, transitions in the replay memory are more recent: they are generated by following policies whose parameters are closer to version of the parameters being optimized by the learner, and in this sense they are more onpolicy. Could this alone be sufficient to explain the improved performance? If so, we might be able to recover the results without needing a large number of actor machines. To test this, we constructed an experiment wherein we replicate the rate at which the contents of the replay memory is replaced in the 256-actor experiments, but instead of actually using 256 actors, we use 32 actors but add each transition they generate to the replay memory 8 times over. In this setup, the contents of the replay memory is similarly generated by policies with a recent version of the network parameters: the only difference is that the data is not as diverse as in the 256-actor case. We observe (see Figure 6) that this does not recover the same performance, and therefore conclude that the recency of the experience alone is not sufficient to explain the performance of our method. Indeed, we see that adding the same data multiple times can sometimes harm performance, since although it increases recency this comes at the expense of diversity. ",
+        "bbox": [
+            173,
+            487,
+            825,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Note: in principle, duplicating the added data in this fashion has a similar effect to reducing the capacity of the replay memory, and indeed, our results with a smaller replay memory in Figure 5 do corroborate the finding. However, we test also by duplicating the data primarily in order to exclude any effects arising from the implementation. In particular, in contrast to simply reducing the replay capacity, duplicating each data point means that the computational demands on the replay server in these runs are the same as when we use the corresponding number of real actors. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            799
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B VARYING THE DATA-GENERATING POLICIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            578,
+            838
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Another factor that could conceivably contribute to the scalability of our algorithm is the fact that each actor has a different $\\epsilon$ . To determine the extent to which this impacts upon the performance, we ran an experiment (see Figure 7) with some simple variations on the mechanism we use to choose the policies that generate the data we train on. The first alternative we tested is to choose a small fixed set of 6 values for $\\epsilon$ , instead of the full range that we typically use. In this test, we use prioritized ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "replay as normal, and we find that the results with the full range of $\\epsilon$ are overall slightly better.   \nHowever, it is not essential for achieving good results within our distributed framework. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ATARI: ADDITIONAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            460,
+            169
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The frames received from the environment are preprocessed on the actor side with the standard transformations introduced by DQN. This includes greyscaling, frame stacking, repeating actions 4 times, and clipping rewards to $[ - 1 , 1 ]$ . ",
+        "bbox": [
+            174,
+            184,
+            825,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The learner waits for at least 50000 transitions to be accumulated in the replay before starting learning. We use a Centered RMSProp optimizer with a learning rate of $0 . 0 0 0 2 5 \\mid 4$ , decay of 0.95, epsilon of 1.5e-7, and no momentum to minimize the multi-step loss (with $n = 3$ ). Gradient norms are clipped to 40. The target network used in the loss calculation is copied from the online network every 2500 training batches. We use the same network as in the Dueling DDQN agent. ",
+        "bbox": [
+            174,
+            233,
+            825,
+            303
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D CONTINUOUS CONTROL: ADDITIONAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            323,
+            611,
+            339
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The critic network has a layer with 400 units, followed by a tanh activation, followed by another layer of 300 units. The actor network has a layer with 300 units, followed by a tanh activation, followed by another layer of 200 units. The gradient used to update the actor network is clipped to $[ - 1 , 1 ]$ , element-wise. Training uses the Adam optimizer (Kingma & Ba (2014)) with learning rate of 0.0001. The target network used in the loss calculation is copied from the online network every 100 training batches. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            439
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Replay sampling priorities are set according to the absolute TD error as given by the critic, and are sampled by the learner using proportional prioritized sampling (see appendix F) with priority exponent $\\alpha _ { \\mathrm { s a m p l e } } = 0 . 6$ . To maintain a fixed replay capacity of $\\mathrm { { \\bar { 1 } 0 ^ { 6 } } }$ , transitions are periodically evicted using proportional prioritized sampling, with priority exponent $\\alpha _ { \\mathrm { e v i c t } } = - 0 . 4$ . This is a different strategy for removing data than in the Atari experiments, which simply removed the oldest data first - it remains to be seen which is superior. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            529
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Unlike the original DPG algorithm which applies autocorrelated noise sampled from a OrnsteinUhlenbeck process (Uhlenbeck & Ornstein (1930)), we apply exploration noise to each action sampled from a normal distribution with $\\sigma = 0 . 3$ . Evaluation is performed using the noiseless deterministic policy. Hyperparameters are otherwise as per DQN. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            592
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Benchmarking was performed in two continuous control domains ((a) Humanoid and (b) Manipulator, see Figure 8) implemented in the MuJoCo physics simulator (Todorov et al. (2012)). Humanoid is a humanoid walker with action, state and observation dimensionalities $| { \\mathcal { A } } | = 2 1$ , $| S | = 5 5$ and $| \\mathcal { O } | = 6 7 $ respectively. Three Humanoid tasks were considered: walk (reward for exceeding a minimum velocity), run (reward proportional to movement speed) and stand (reward proportional to standing height). Manipulator is a 2-dimensional planar arm with $| { \\mathcal { A } } | = 2$ , $| { \\cal S } | = 2 2$ and $| \\mathcal { O } | = 3 7 $ , which receives reward for catching a randomly-initialized moving ball. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            696
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/c04f7fbc75193c4384545a137f0703d706d7c1e0178b4bf3f6ed9b0066f21e1c.jpg",
+        "image_caption": [
+            "Figure 8: Continuous control domains considered for benchmarking Ape-X DPG: (a) Humanoid, and (b) Manipulator. All tasks simulated in the MuJoCo physics simulator (Todorov et al. (2012)). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            709,
+            759,
+            880
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E TUNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            276,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "On Atari, we performed some limited tuning of the learning rate and batch size: we found that larger batch sizes contribute significantly to performance, when using many actors. We tried batch sizes from $\\{ 3 2 , 1 2 8 , 2 5 6 , 5 1 2 , 1 0 2 4 \\}$ , seeing clear benefits up to 512. We attempted increasing the learning rate to 0.00025 with the larger batch sizes but this destabilized training on some games. We also tried a lower learning rate of $0 . 0 0 0 2 5 / 8$ , but this did not reliably improve results. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            204
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Likewise for continuous control, we experimented with batch sizes $\\{ 3 2 , 1 2 8 , 2 5 6 , 5 1 2 , 1 0 2 4 \\}$ and learning rates from $1 0 ^ { - 3 }$ to $1 0 ^ { - 5 }$ . We also experimented with the prioritization exponents $\\alpha$ from 0.0 to 1.0, with results proving essentially consistent within the range [0.3, 0.7] (beyond 0.7, training would sometimes become unstable and diverge). ",
+        "bbox": [
+            174,
+            212,
+            825,
+            267
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the experiments with many actors, we set the period for updating network parameters on the actors to be high enough that the learner was not overloaded with requests, and we set the number of transitions that are locally accumulated on each actor to be high enough that the replay server would not be overloaded with network traffic, but we did not otherwise tune those parameters and have not observed them to have significant impact on the learning dynamics. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            344
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            357,
+            382
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The following section makes explicit some of the more practical details that may be of interest to anyone wishing to implement a similar system. ",
+        "bbox": [
+            174,
+            398,
+            823,
+            426
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Data Storage The algorithm is implemented using TensorFlow (Abadi et al., 2016). Replay data is kept in a distributed in-memory key-value store implemented using custom TensorFlow ops, similar to the lookup ops available in core TensorFlow. The ops allow adding, reading, and removing batches of Tensor data efficiently. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            500
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Sampling Data We also implemented ops for efficiently maintaining and sampling from a prioritized distribution over the keys, using the algorithm for proportional prioritization described in Schaul et al. (2016). The probability of sampling a transition is $p _ { k } ^ { \\alpha } / \\sum _ { k } \\bar { p _ { k } ^ { \\alpha } }$ where $p _ { k }$ is the priority of the transition with key $k$ . The exponent $\\alpha$ controls the amount of prioritization, and when $\\alpha = 0$ uniform sampling is recovered. The proportional variant sets priority $p _ { k } \\ = \\ | \\delta _ { k } |$ where $\\delta _ { k }$ is the TD error for transition $k$ . Whenever a batch of data is added to or removed from the store, or is processed by the learner, this distribution is correspondingly updated, recording any change to the set of valid keys and the priorities associated with them. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            628
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A background thread on the learner fetches batches of sampled data from the remote replay and decompresses it using the learner’s CPU, in parallel with the gradients being computed on the GPU. The fetched data is buffered in a TensorFlow queue, so that the GPU always has data available to train on. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Adding Data In order to efficiently construct $n$ -step transition data, each actor maintains a circular buffer of capacity $n$ containing tuples $( S _ { t } , A _ { t } , R _ { t : t + B } , \\gamma _ { t : t + B } , q ( S _ { t } , * ) )$ , where $B$ is the current size of the buffer. With each step, the new data is appended and the accumulated per-step discounts $\\gamma _ { t : t + B }$ and partial returns $R _ { t : t + B }$ for all entries in the buffer are updated. If the buffer has reached its capacity, $n$ , then its first element may be combined with the latest state $S _ { t + n }$ and value estimates $q ( S _ { t + n } )$ to produce a valid $n$ -step transition (with accompanying Q-values). ",
+        "bbox": [
+            174,
+            708,
+            825,
+            791
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "However, instead of being directly added to the remote replay memory on each step, the constructed transitions $( S _ { t } , A _ { t } , R _ { t : t + B } , \\gamma _ { t : t + B } , S _ { t + n } , q ( S _ { t } , * ) , q ( S _ { t + n } , * ) )$ are first stored in a local TensorFlow queue, in order to reduce the number of requests to the replay server. The queue is periodically flushed, at which stage the absolute $n$ -step TD-errors (and thus the initial priorities) for the queued transitions are computed in batch, using the buffered Q-values to avoid recomputation. The Q-value estimates from which the initial priorities are derived are therefore based on the actor’s copy of the network parameters at the time the corresponding state was obtained from the environment, rather than the latest version on the learner. These $\\mathbf { Q }$ -values need not be stored after this, since the learner does not require them, although they can be helpful for debugging. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A unique key is assigned to each transition, which records which actor and environment step it came from, and the dequeued transition tuples are stored in the remote replay memory. As mentioned in the previous section, the remote sampling distribution is immediately updated with the newly added keys and the corresponding initial priorities computed by the actor. Note that, since we store both the start and the end state with each transition, we are storing some data twice: this costs more RAM, but simplifies the code. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Contention It is important that the replay server be able to handle all requests in a timely fashion, in order to avoid slowing down the whole system. Possible bottlenecks include CPU, network bandwidth, and any locks protecting the shared data. In our experiments we found CPU to be the main bottleneck, but this was resolved by ensuring all requests and responses use sufficiently large batches. Nonetheless, it is advisable to consider all of these potential performance concerns when designing such systems. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            286
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Asynchronicity In our framework, since acting and learning proceed with no synchronization, and performance depends on both, it can be misleading to consider performance with reference to only one of these. For example, the results after a given total number of environment frames have been experienced are highly dependent on the number of updates the learner has performed in that time. For this reason it is important to monitor and report the speeds of all parts of the system and to consider them when analyzing results. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            386
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Failure Tolerance In distributed systems with many workers, it is inevitable that interruptions or failures will occur, either due to occasional hardware issues or because shared resources are needed by higher priority jobs. All stateful parts of the system therefore must periodically save their work and be able to resume where they left off when restarted. In our system, actors may be interrupted at any time and this will not prevent continued learning, albeit with a temporarily reduced rate of new data entering the replay memory. If the replay server is interrupted, the data it contains is discarded, and upon resuming, the memory is refilled quickly by the actors. In this event, to avoid overfitting, the learner will pause training briefly, until the minimum amount of data has once again been accumulated. If the learner is interrupted, progress will stall until it resumes. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            526
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/f578ecace5631d994bfd6279c4a5b44e57e882eb2f40a5e4adb97fbe30a17601.jpg",
+        "image_caption": [
+            "Figure 9: Training curves for 57 Atari games (performance against wall clock time). Green: DQN baseline. Purple: Rainbow baseline. Orange: A3C baseline. Blue: Ape-X DQN with 360 actors, 1 replay server and 1 Tesla P100 GPU learner. The anomaly in Riverraid is due to an infrastructure error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            85,
+            810,
+            888
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/3eb2bc35890285b38016f9dae3b07dda38be8f504cbc44310a8983cea36fcd27.jpg",
+        "image_caption": [
+            "Figure 10: Training curves for 57 Atari games (performance against environment frames). Only the first billion frames are shown, corresponding to 5-6 hours of training for Ape-X. Green: DQN baseline. Purple: Rainbow baseline. Blue: ApeX-DQN with 360 actors, 1 replay server and 1 Tesla P100 GPU learner. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            80,
+            810,
+            890
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/9bbe7c32a5e256e54b199dfb3d84b82cfd5bda6cad739084413d788ef824056c.jpg",
+        "image_caption": [
+            "Figure 11: Speed of data generation scales linearly with the number of actors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            362,
+            109,
+            612,
+            247
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/25f8f42a218da06e8d3b75e6b039fd7548d3de2b9965679f63ba47f0781d1ef1.jpg",
+        "image_caption": [
+            "Figure 12: Training curves showing performance against wall clock time for various numbers of actors on a selection of Atari games. Blue: prioritized replay, with learning rate $0 . 0 0 0 2 5 \\mid 4$ . Red: uniform replay, with learning rate 0.00025. For both prioritized and uniform, we tried both of these learning rates and selected the best. Both variants benefit from larger numbers of actors, but prioritized can better take advantage of the increased amount of data. In the 256-actor run, prioritized is equal or better in 7 of 9 games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            275,
+            795,
+            861
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/a4584ee57d7ed0fc4dc4e719baafa1a7a8c94f278a14f7605e7da3bca357387e.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Scores obtained by Ape-X DQN in final evaluation, under the standard no-op starts and human starts regimes. In some games the scores are higher than in the training curves: this is because the maximum episode length is shorter during training. 19 "
+        ],
+        "table_body": "<table><tr><td>Game</td><td>No-op starts</td><td>Human starts</td></tr><tr><td></td><td>40,804.9</td><td>17,731.5</td></tr><tr><td>alien</td><td></td><td>1,047.3</td></tr><tr><td>amidar</td><td>8,659.2</td><td></td></tr><tr><td>assault</td><td>24,559.4</td><td>24,404.6</td></tr><tr><td>asterix</td><td>313,305.0</td><td>283,179.5</td></tr><tr><td>asteroids</td><td>155,495.1</td><td>117,303.4</td></tr><tr><td>atlantis</td><td>944,497.5</td><td>918,714.5</td></tr><tr><td>bank_heist battle_zone</td><td>1,716.4</td><td>1,200.8</td></tr><tr><td>beam_rider</td><td>98,895.0</td><td>92,275.0</td></tr><tr><td>berzerk</td><td>63,305.2 57,196.7</td><td>72,233.7 55,598.9</td></tr><tr><td>bowling</td><td>17.6</td><td>30.2</td></tr><tr><td>boxing</td><td>100.0</td><td>80.9</td></tr><tr><td>breakout</td><td>800.9</td><td>756.5</td></tr><tr><td>centipede</td><td>12,974.0</td><td>5,711.6</td></tr><tr><td>chopper_command</td><td>721,851.0</td><td>576,601.5</td></tr><tr><td>crazy_climber</td><td>320,426.0</td><td>263,953.5</td></tr><tr><td>defender</td><td>411,943.5</td><td>399,865.3</td></tr><tr><td>demon_attack</td><td>133,086.4</td><td>133,002.1</td></tr><tr><td>double_dunk</td><td>23.5</td><td>22.3</td></tr><tr><td>enduro</td><td>2,177.4</td><td>2,042.4</td></tr><tr><td>fishing_derby</td><td>44.4</td><td>22.4</td></tr><tr><td>freeway</td><td>33.7</td><td>29.0</td></tr><tr><td>frostbite</td><td>9,328.6</td><td>6,511.5</td></tr><tr><td>gopher</td><td>120,500.9</td><td>121,168.2</td></tr><tr><td>gravitar</td><td>1,598.5</td><td>662.0</td></tr><tr><td>hero</td><td>31,655.9</td><td>26,345.3</td></tr><tr><td>ice_hockey</td><td>33.0</td><td>24.0</td></tr><tr><td>jamesbond</td><td>21,322.5</td><td>18,992.3</td></tr><tr><td>kangaroo</td><td>1,416.0</td><td>577.5</td></tr><tr><td>krull</td><td>11,741.4</td><td>8,592.0</td></tr><tr><td>kung_fu_master</td><td>97,829.5</td><td>72,068.0</td></tr><tr><td>montezuma_revenge</td><td>2,500.0</td><td>1,079.0</td></tr><tr><td>ms_pacman</td><td>11,255.2</td><td>6,135.4</td></tr><tr><td>name_this-game</td><td>25,783.3</td><td>23,829.9</td></tr><tr><td>phoenix</td><td>224,491.1</td><td>188,788.5</td></tr><tr><td>pitfall</td><td>-0.6</td><td>-273.3</td></tr><tr><td>pong</td><td>20.9</td><td>18.7</td></tr><tr><td>private_eye</td><td>49.8</td><td>864.7</td></tr><tr><td>qbert</td><td>302,391.3</td><td>380,152.1</td></tr><tr><td>riverraid</td><td>63,864.4</td><td></td></tr><tr><td>road_runner</td><td>222,234.5</td><td>49,982.8</td></tr><tr><td>robotank</td><td>73.8</td><td>127,111.5</td></tr><tr><td>seaquest</td><td>392,952.3</td><td>68.5</td></tr><tr><td>skiing</td><td>-10,789.9</td><td>377,179.8</td></tr><tr><td>solaris</td><td>2,892.9</td><td>-11,359.3</td></tr><tr><td>space_invaders</td><td></td><td>3,115.9</td></tr><tr><td></td><td>54,681.0</td><td>50,699.3</td></tr><tr><td>star_gunner</td><td>434,342.5</td><td>432,958.0</td></tr><tr><td>surround</td><td>7.1</td><td>5.5</td></tr><tr><td>tennis</td><td>23.9</td><td>23.0</td></tr><tr><td>time_pilot</td><td>87,085.0</td><td>71,543.0</td></tr><tr><td>tutankham</td><td>272.6</td><td>127.7</td></tr><tr><td>up_n_down</td><td>401,884.3</td><td>347,912.2</td></tr><tr><td>venture</td><td>1,813.0</td><td>935.5</td></tr><tr><td>video_pinball</td><td>565,163.2</td><td>873,988.5</td></tr><tr><td>wizard_of_wor</td><td>46,204.0</td><td>46,897.0</td></tr><tr><td>yars_revenge zaxxon</td><td>148,594.8 42,285.5</td><td>131,701.1 37,672.0</td></tr></table>",
+        "bbox": [
+            326,
+            92,
+            673,
+            914
+        ],
+        "page_idx": 18
+    }
+]

parse/train/I6NRcao1w-X/I6NRcao1w-X.md

@@ -0,0 +1,405 @@
+# ROBUST REINFORCEMENT LEARNING USING ADVERSARIAL POPULATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Reinforcement Learning (RL) is an effective tool for controller design but can struggle with issues of robustness, failing catastrophically when the underlying system dynamics are perturbed. The Robust RL formulation tackles this by adding worst-case adversarial noise to the dynamics and constructing the noise distribution as the solution to a zero-sum minimax game. However, existing work on learning solutions to the Robust RL formulation has primarily focused on training a single RL agent against a single adversary. In this work, we demonstrate that using a single adversary does not consistently yield robustness to dynamics variations under standard parametrizations of the adversary; the resulting policy is highly exploitable by new adversaries. We propose a population-based augmentation to the Robust RL formulation in which we randomly initialize a population of adversaries and sample from the population uniformly during training. We empirically validate across robotics benchmarks that the use of an adversarial population results in a less exploitable, more robust policy. Finally, we demonstrate that this approach provides comparable robustness and generalization as domain randomization on these benchmarks while avoiding a ubiquitous domain randomization failure mode.
+
+# 1 INTRODUCTION
+
+Developing controllers that work effectively across a wide range of potential deployment environments is one of the core challenges in engineering. The complexity of the physical world means that the models used to design controllers are often inaccurate. Optimization based control design approaches, such as reinforcement learning (RL), have no notion of model inaccuracy and can lead to controllers that fail catastrophically under mismatch. In this work, we aim to demonstrate an effective method for training reinforcement learning policies that are robust to model inaccuracy by designing controllers that are effective in the presence of worst-case adversarial noise in the dynamics.
+
+An easily automated approach to inducing robustness is to formulate the problem as a zero-sum game and learn an adversary that perturbs the transition dynamics (Tessler et al., 2019; Kamalaruban et al., 2020; Pinto et al., 2017). If a global Nash equilibrium of this problem is found, then that equilibrium provides a lower bound on the performance of the policy under some bounded set of perturbations. Besides the benefit of removing user design once the perturbation mechanism is specified, this approach is maximally conservative, which is useful for safety critical applications.
+
+However, the literature on learning an adversary predominantly uses a single, stochastic adversary. This raises a puzzling question: the zero-sum game does not necessarily have any pure Nash equilibria (see Appendix C in Tessler et al. (2019)) but the existing robust RL literature mostly appears to attempt to solve for pure Nash equilibria. That is, the most general form of the minimax problem searches over distributions of adversary and agent policies, however, this problem is approximated in the literature by a search for a single agent-adversary pair. We contend that this reduction to a single adversary approach can sometimes fail to result in improved robustness under standard parametrizations of the adversary policy.
+
+The following example provides some intuition for why using a single adversary can decrease robustness. Consider a robot trying to learn to walk east-wards while an adversary outputs a force representing wind coming from the north or the south. For a fixed, deterministic adversary the agent knows that the wind will come from either south or north and can simply apply a counteracting force at each state. Once the adversary is removed, the robot will still apply the compensatory forces and possibly become unstable. Stochastic Gaussian policies (ubiquitous in continuous control) offer little improvement: they cannot represent multi-modal perturbations. Under these standard policy parametrizations, we cannot use an adversary to endow the agent with a prior that a strong wind could persistently blow either north or south. This leaves the agent exploitable to this class of perturbations.
+
+The use of a single adversary in the robustness literature is in contrast to the multi-player game literature. In multi-player games, large sets of adversaries are used to ensure that an agent cannot easily be exploited (Vinyals et al., 2019; Czarnecki et al., 2020; Brown & Sandholm, 2019). Drawing inspiration from this literature, we introduce RAP (Robustness via Adversary Populations): a randomly initialized population of adversaries that we sample from at each rollout and train alongside the agent. Returning to our example of a robot perturbed by wind, if the robot learns to cancel the north wind effectively, then that opens a niche for an adversary to exploit by applying forces in another direction. With a population, we can endow the robot with the prior that a strong wind could come from either direction and that it must walk carefully to avoid being toppled over.
+
+Our contributions are as follows:
+
+• Using a set of continuous robotics control tasks, we provide evidence that a single adversary does not have a consistent positive impact on the robustness of an RL policy while the use of an adversary population provides improved robustness across all considered examples. We investigate the source of the robustness and show that the single adversary policy is exploitable by new adversaries whereas policies trained with RAP are robust to new adversaries. • We demonstrate that adversary populations provide comparable robustness to domain randomization while avoiding potential failure modes of domain randomization.
+
+# 2 RELATED WORK
+
+This work builds upon robust control (Zhou & Doyle, 1998), a branch of control theory focused on finding optimal controllers under worst-case perturbations of the system dynamics. The Robust Markov Decision Process (R-MDP) formulation extends this worst-case model uncertainty to uncertainty sets on the transition dynamics of an MDP and demonstrates that computationally tractable solutions exist for small, tabular MDPs (Nilim & El Ghaoui, 2005; Lim et al., 2013). For larger or continuous MDPs, one successful approach has been to use function approximation to compute approximate solutions to the R-MDP problem (Tamar et al., 2014).
+
+One prominent variant of the R-MDP literature is to interpret the perturbations as an adversary and attempt to learn the distribution of the perturbation under a minimax objective. Two variants of this idea that tie in closely to our work are Robust Adversarial Reinforcement Learning (RARL)(Pinto et al., 2017) and Noisy Robust Markov Decision Processes (NR-MDP) (Tessler et al., 2019) which differ in how they parametrize the adversaries: RARL picks out specific robot joints that the adversary acts on while NR-MDP adds the adversary action to the agent action. Both of these works attempt to find an equilibrium of the minimax objective using a single adversary; in contrast our work uses a large set of adversaries and shows improved robustness relative to a single adversary.
+
+A strong alternative to the minimax objective, domain randomization, asks a designer to explicitly define a distribution over environments that the agent should be robust to. For example, (Peng et al., 2018) varies simulator parameters to train a robot to robustly push a puck to a target location in the real world; (Antonova et al., 2017) adds noise to friction and actions to transfer an object pivoting policy directly from simulation to a Baxter robot. Additionally, domain randomization has been successfully used to build accurate object detectors solely from simulated data (Tobin et al., 2017) and to zero-shot transfer a quadcopter flight policy from simulation (Sadeghi & Levine, 2016).
+
+The use of population based training is a standard technique in multi-agent settings. Alphastar, the grandmaster-level Starcraft bot, uses a population of "exploiter" agents that fine-tune against the bot to prevent it from developing exploitable strategies (Vinyals et al., 2019). (Czarnecki et al., 2020) establishes a set of sufficient geometric conditions on games under which the use of multiple adversaries will ensure gradual improvement in the strength of the agent policy. They empirically demonstrate that learning in games can often fail to converge without populations. Finally, Active Domain Randomization (Mehta et al., 2019) is a very close approach to ours, as they use a population of adversaries to select domain randomization parameters whereas we use a population of adversaries to directly perturb the agent actions. However, they explicitly induce diversity using a repulsive term and use a discriminator to generate the reward.
+
+# 3 BACKGROUND
+
+In this work we use the framework of a multi-agent, finite-horizon, discounted, Markov Decision Process (MDP) (Puterman, 1990) defined by a tuple $\langle A _ { \mathrm { a g e n t } } \times A _ { \mathrm { a d v e r s a r y } } , S , \mathcal { T } , r , \gamma \rangle$ . Here $A _ { \mathrm { a g e n t } }$ is the set of actions for the agent, $A _ { \mathrm { a d v e r s a r y } }$ is the set of actions for the adversary, $S$ is a set of states, $\mathcal { T } : A _ { \mathrm { a g e n t } } \times A _ { \mathrm { a d v e r s a r y } } \times S \to \Delta ( S )$ is a transition function, $r : A _ { \mathrm { a g e n t } } \times A _ { \mathrm { a d v e r s a r y } } \times S  \mathbb { R }$ is a reward function and $\gamma$ is a discount factor. $S$ is shared between the adversaries as they share a state-space with the agent. The goal for a given MDP is to find a policy $\pi _ { \theta }$ parametrized by $\theta$ that maximizes the expected cumulative discounted reward $\begin{array} { r } { J ^ { \theta } = \mathbb { E } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } , a _ { t } ) | \pi _ { \theta } \right] } \end{array}$ . The conditional in this expression is a short-hand to indicate that the actions in the MDP are sampled via $a _ { t } \sim \pi _ { \theta } ( s _ { t } , a _ { t - 1 } )$ . We denote the agent policy parametrized by weights $\theta$ as $\pi _ { \theta }$ and the policy of adversary $i$ as $\bar { \pi } _ { \phi _ { i } }$ . Actions sampled from the adversary policy $\bar { \pi } _ { \phi _ { i } }$ will be written as $\bar { a } _ { t } ^ { i }$ . We use $\xi$ to denote the parametrization of the system dynamics (e.g. different values of friction, mass, wind, etc.) and the system dynamics for a given state and action as $s _ { t + 1 } \sim f _ { \xi } ( s _ { t } , a _ { t } )$ .
+
+# 3.1 BASELINES
+
+Here we outline prior work and the approaches that will be compared with RAP. Our baselines consist of a single adversary and domain randomization.
+
+# 3.1.1 SINGLE MINIMAX ADVERSARY
+
+Our adversary formulation uses the Noisy Action Robust MDP (Tessler et al., 2019) in which the adversary adds its actions onto the agent actions. The objective is
+
+$$
+\begin{array} { r l } & { \underset { \theta } { \operatorname* { m a x } } \mathbb { E } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } , a _ { t } + \alpha \bar { a _ { t } } ) | \pi _ { \theta } , \ \bar { \pi } _ { \phi } \right] } \\ & { \underset { \phi } { \operatorname* { m i n } } \mathbb { E } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } , a _ { t } + \alpha \bar { a _ { t } } ) | \pi _ { \theta } , \ \bar { \pi } _ { \phi } \right] } \end{array}
+$$
+
+where $\alpha$ is a hyperparameter controlling the adversary strength. This is a game in which the adversary and agent play simultaneously. We note an important restriction inherent to this adversarial model. Since the adversary is only able to attack the agent through the actions, there is a restricted class of dynamical systems that it can represent; this set of dynamical systems may not necessarily align with the set of dynamical systems that the agent may be tested in. This is a restriction caused by the choice of adversarial perturbation and could be alleviated by using different adversarial parametrizations e.g. perturbing the transition function directly.
+
+# 3.1.2 DYNAMICS RANDOMIZATION
+
+Domain randomization is the setting in which the user specifies a set of environments which the agent should be robust to. This allows the user to directly encode knowledge about the likely deviations between training and testing domains. For example, the user may believe that friction is hard to measure precisely and wants to ensure that their agent is robust to variations in friction; they then specify that the agent will be trained with a wide range of possible friction values. We use $\xi$ to denote some vector that parametrizes the set of training environments (e.g. friction, masses, system dynamics, etc.). We denote the domain over which $\xi$ is drawn from as $\Xi$ and use ${ \mathcal { P } } \left( { \Xi } \right)$ to denote some probability distribution over $\xi$ . The domain randomization objective is
+
+$$
+\begin{array} { r l } & { \underset { \theta } { \operatorname* { m a x } } \mathbb { E } _ { \xi \sim \mathcal { P } ( \Xi ) } \left[ \mathbb { E } _ { s _ { t + 1 } \sim f _ { \xi } ( s _ { t } , a _ { t } ) } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } , a _ { t } ) | \pi _ { \theta } \right] \right] } \\ & { \quad \quad \quad \quad s _ { t + 1 } \sim f _ { \xi } ( s _ { t } , a _ { t } ) } \\ & { \quad \quad \quad \quad a _ { t } \sim \pi _ { \theta } ( s _ { t } ) } \end{array}
+$$
+
+Here the goal is to find an agent that performs well on average across the distribution of training environment. Most commonly, and in this work, the parameters $\xi$ are sampled uniformly over $\Xi$ .
+
+# 4 RAP: ROBUSTNESS VIA ADVERSARY POPULATIONS
+
+RAP extends the minimax objective with a population based approach. Instead of a single adversary, at each rollout we will sample uniformly from a population of adversaries. By using a population, the agent is forced to be robust to a wide variety of potential perturbations rather than a single perturbation. If the agent begins to overfit to any one adversary, this opens up a potential niche for another adversary to exploit. For problems with only one failure mode, we expect the adversaries to all come out identical to the minimax adversary, but as the number of failure modes increases the adversaries should begin to diversify to exploit the agent. To induce this diversity, we will rely on randomness in the gradient estimates and randomness in the initializations of the adversary networks rather than any explicit term that induces diversity.
+
+Denoting $\bar { \pi } _ { \phi _ { i } }$ as the $i$ -th adversary and $i \sim U ( 1 , n )$ as the discrete uniform distribution defined on 1 through n, the objective becomes
+
+$$
+\cdot
+$$
+
+For a single adversary, this is equivalent to the minimax adversary described in Sec. 3.1.1. This is a game in which the adversary and agent play simultaneously.
+
+We will optimize this objective by converting the problem into the equivalent zero-sum game. At the start of each rollout, we will sample an adversary index from the uniform distribution and collect a trajectory using the agent and the selected adversary. For notational simplicity, we assume the trajectory is of length T and that adversary $i$ will participate in $J _ { i }$ total trajectories while, since the agent participates in every rollout, the agent will receive J total trajectories. We denote the j-th collected trajectory for the agent as τj $\mathbf { \Phi } = \left( s _ { 0 } , a _ { 0 } , r _ { 0 } , s _ { 1 } \right) \times \cdots \times \left( s _ { M } , a _ { M } , r _ { M } , s _ { M + 1 } \right)$ and the associated trajectory for adversary $i$ as $\tau _ { j } ^ { i } = ( s _ { 0 } , a _ { 0 } , - r _ { 0 } , s _ { 1 } ) \times \cdot \cdot \cdot \times ( s _ { M } , a _ { M } , - r _ { M } ,$ sM ). Note that the adversary reward is simply the negative of the agent reward. We will use Proximal Policy Optimization (Schulman et al., 2017) (PPO) to update our policies. We caution that we have overloaded notation slightly here and for adversary $i$ , $\tau _ { j = 1 : J _ { i } } ^ { i }$ refers only to the trajectories in which the adversary was selected: adversaries will only be updated using trajectories where they were active.
+
+At the end of a training iteration, we update all our policies using gradient descent. The algorithm is summarized below:
+
+Initialize $\theta , \phi _ { 1 } \cdots \phi _ { n }$ using Xavier initialization (Glorot & Bengio, 2010);   
+while not converged do for rollout $j { = } l { \ldots } J$ do sample adversary $i \sim U ( 1 , n )$ ; run policies $\pi _ { \theta }$ , $\bar { \pi } _ { \phi _ { i } }$ in environment until termination; collect trajectories $\tau _ { j } , \tau _ { j } ^ { i }$ end update $\theta , \phi _ { 1 } \cdots \phi _ { n }$ using PPO (Schulman et al., 2017) and trajectories $\tau _ { j }$ for $\theta$ and $\tau _ { j } ^ { i }$ for each $\phi _ { i }$ ;   
+end
+
+# 5 EXPERIMENTS
+
+In this section we present experiments on continuous control tasks from the OpenAI Gym Suite (Brockman et al., 2016; Todorov et al., 2012). We compare with the existing literature and evaluate the efficacy of a population of learned adversaries across a wide range of state and action space sizes. We investigate the following hypotheses:
+
+H1. Agents are more likely to overfit to a single adversary than a population of adversaries, leaving them less robust on in-distribution tasks.   
+H2. Agents trained against a population of adversaries will generalize better, leading to improved performance on out-of-distribution tasks.
+
+In-distribution tasks refer to the agent playing against perturbations that are in the training distribution: adversaries that add their actions onto the agent. However, the particular form of the adversary and their restricted perturbation magnitude means that there are many dynamical systems that they cannot represent (for example, significant variations of joint mass and friction). These tasks are denoted as out-of-distribution tasks. All of the tasks in the test set described in Sec. 5.1 are likely out-of-distribution tasks.
+
+# 5.1 EXPERIMENTAL SETUP AND HYPERPARAMETER SELECTION
+
+While we provide exact details of the hyperparameters in the Appendix, adversarial settings require additional complexity in hyperparameter selection. In the standard RL procedure, optimal hyperparameters are selected on the basis of maximum expected cumulative reward. However, if an agent playing against an adversary achieves a large cumulative reward, it is possible that the agent was simply playing against a weak adversary. Conversely, a low score does not necessarily indicate a strong adversary nor robustness: it could simply mean that we trained a weak agent.
+
+To address this, we adopt a version of the train-validate-test split from supervised learning. We use the mean policy performance on a suite of validation tasks to select the hyperparameters, then we train the policy across ten seeds and report the resultant mean and standard deviation over twenty trajectories. Finally, we evaluate the seeds on a holdout test set of eight additional model-mismatch tasks. These tasks vary significantly in difficulty; for visual clarity we report the average across tasks in this paper and report the full breakdown across tasks in the Appendix.
+
+We experiment with the Hopper, Ant, and Half Cheetah continuous control environments used in the original RARL paper Pinto et al. (2017); these are shown in Fig. 1. To generate the validation model mismatch, we pre-define ranges of mass and friction coefficients as follows: for Hopper, mass $\in [ 0 . 7 , 1 . 3 ]$ and friction $\in [ 0 . 7 , 1 . 3 ]$ ; Half Cheetah and Ant, mass $\in [ 0 . 5 , 1 . 5 ]$ and friction $\in [ 0 . 1 , 0 . 9 ]$ We scale the friction of every Mujoco geom and the mass of the torso with the same (respective) coefficients. We compare the robustness of agents trained via RAP against: 1) agents trained against a single adversary in a zero-sum game, 2) oracle agents trained using domain randomization, and 3) an agent trained only using PPO and no perturbation mechanism. To train the domain randomization oracle, at each rollout we uniformly sample a friction and mass coefficient from the validation set ranges. We then scale the friction of all geoms and the mass of the torso by their respective coefficients; this constitutes directly training on the validation set. To generate the test set of model mismatch, we take both the highest and lowest friction coefficients from the validation range and apply them to different combinations of individual geoms. For the exact selected combinations, please refer to the Appendix.
+
+![](images/b494ff0afc0a87678660ef4893645f71f8a360ad511ce83c8fafe9afd752c6c9.jpg)  
+Figure 1: From left to right, the Hopper, Half-Cheetah, and Ant environments we use to test our algorithm.
+
+As further validation of the benefits of RAP, we include an additional set of experiments on a continuous control task, a gridworld maze search task, and a Bernoulli Bandit task in Appendix Sec. F. Finally, we note that both our agent and adversary networks are two layer-neural networks with 64 hidden units in each layer and a tanh nonlinearity.
+
+# 6 RESULTS
+
+# H1. In-Distribution Tasks: Analysis of Overfitting
+
+A globally minimax optimal adversary should be unexploitable and perform equally well against any adversary of equal strength. We investigate the optimality of our policy by asking whether the minimax agent is robust to swaps of adversaries from different training runs, i.e. different seeds. Fig. 2 shows the result of these swaps for the one adversary and three adversary case. The diagonal corresponds to playing against the adversaries the agent was trained with while every other square corresponds to playing against adversaries from a different seed. To simplify presentation, in the three adversary case, each square is the average performance against all the adversaries from that seed. We observe that the agent trained against three adversaries (top row right) is robust under swaps while the single adversary case is not (top row left). The agent trained against a single adversary is highly exploitable, as can be seen by its extremely sub-par performance against an adversary from any other seed. Since the adversaries off-diagonal are feasible adversaries, this suggests that we have found a poor local optimum of the objective.
+
+In contrast, the three adversary case is generally robust regardless of which adversary it plays against, suggesting that the use of additional adversaries has made the agent more robust. One possible hypothesis for why this could be occurring is that the adversaries in the $\cdot$ adversary" case are somehow weaker than the adversaries in the "1 adversary" case. The middle row of the figure shows that it is not the case that the improved performance of the agent playing against the three adversaries is due to some weakness of the adversaries. If anything, the adversaries from the three adversary case are stronger as the agent trained against 1 adversary does extremely poorly playing against the three adversaries (left) whereas the agent trained against three adversaries still performs well when playing against the adversaries from the single-adversary runs. Finally, the bottom row investigates how an agent trained with domain randomization fairs against adversaries from either training regimes. In neither case is the domain randomization agent robust on these tasks.
+
+# H2. Out-of-Distribution Tasks: Robustness and Generalization of Population Training
+
+Here we present the results from the validation and holdout test sets described in Section 5.1. We compare the performance of training with adversary populations of size three and five against vanilla PPO, the domain randomization oracle, and the single minimax adversary. We refer to domain randomization as an oracle as it is trained directly on the test distribution.
+
+Fig.6 shows the average reward (the average of ten seeds across the validation or test sets respectively) for each environment. Table 1 gives the corresponding numerical values and the percent change of each policy from the baseline. Standard deviations are omitted on the test set due to wide variation in task difficulty; the individual tests that we aggregate here are reported in the Appendix with appropriate error bars. In all environments we achieve a higher reward across both the validation and holdout test set using RAP of size three and/or five when compared to the single minimax adversary case. These results from testing on new environments with altered dynamics supports hypothesis H2. that training with a population of adversaries leads to more robust policies than training with a single adversary in out-of-distribution tasks. Furthermore, while the performance is only comparable with the domain randomization oracle, the adversarial approach does not require prior engineering of appropriate randomizations. Furthermore, despite domain randomization being trained directly on these out-of-distribution tasks, domain randomization can have serious failure modes of domain randomization due to its formulation. A detailed analysis of this can be found in Appendix E.
+
+![](images/c96b3e081478b5903c6ee5742f75eae03ef9bbd7b6d16b82b853e46086c0a4fe.jpg)  
+Figure 2: Top row: Average cumulative reward under swaps for one adversary training (left) and three-adversary training (right). Each square corresponds to 20 trials. In the three adversary case, each square is the average performance against the adversaries from that seed. Middle row: (Left) Playing the agent trained against 1 adversary against the adversaries from the three adversary case. (Right) Playing the agent trained against 3 adversaries against the adversaries from the one adversary case. Bottom row: (Left) Playing the DR agent against the adversaries from the three adversary case. (Right) Playing the DR agent against the adversaries from the one adversary case.
+
+For a more detailed comparison of robustness across the validation set, Fig. 4 shows heatmaps of the performance across all the mass, friction coefficient combinations. Here we highlight the heatmaps for Hopper and Half Cheetah for vanilla PPO, domain randomization oracle, single adversary, and best adversary population size. Additional heatmaps for other adversary population sizes and the Ant environment can be found in the Appendix. Note that Fig. 4 is an example of a case where a single adversary has negligible effect on or slightly reduces the performance of the resultant policy on the
+
+![](images/b8d6b0e6efa073cd552745d8cc34bbeee4f1b9b69edea0045c35dcc5c43cb940.jpg)  
+Figure 3: Average reward for Ant, Hopper, and Cheetah environments across ten seeds and across the validation set (top row) and across the holdout test set (bottom row). We compare vanilla PPO, the domain randomization oracle, and the minimax adversary against RAP of size three and five. Bars represent the mean and the arms represent the std. deviation. Both are computed over 20 rollouts for each test-set sample. The std. deviation for the test set are not reported here for visual clarity due to the large variation in holdout test difficulty.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=5>Validation</td><td rowspan=1 colspan=5>Test</td></tr><tr><td rowspan=1 colspan=1>Ant</td><td rowspan=1 colspan=1>0 Adv</td><td rowspan=1 colspan=1>DR</td><td rowspan=1 colspan=1>1Adv</td><td rowspan=1 colspan=1>3 Adv</td><td rowspan=1 colspan=1>5 Adv</td><td rowspan=1 colspan=1>0 Adv</td><td rowspan=1 colspan=1>DR</td><td rowspan=1 colspan=1>1 Adv</td><td rowspan=1 colspan=1>3 Adv</td><td rowspan=1 colspan=1>5 Adv</td></tr><tr><td rowspan=1 colspan=1>Mean Rew.% Change</td><td rowspan=1 colspan=1>6336</td><td rowspan=1 colspan=1>67436.4</td><td rowspan=1 colspan=1>63490.2</td><td rowspan=1 colspan=1>64321.5</td><td rowspan=1 colspan=1>64381.6</td><td rowspan=1 colspan=1>2908</td><td rowspan=1 colspan=1>361324.3</td><td rowspan=1 colspan=1>320610.2</td><td rowspan=1 colspan=1>327212.5</td><td rowspan=1 colspan=1>320310.2</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=5>Validation</td><td rowspan=1 colspan=5>Test</td></tr><tr><td rowspan=1 colspan=1>Hopper</td><td rowspan=1 colspan=1>0 Adv</td><td rowspan=1 colspan=1>DR</td><td rowspan=1 colspan=1>1 Adv</td><td rowspan=1 colspan=1>3 Adv</td><td rowspan=1 colspan=1>5 Adv</td><td rowspan=1 colspan=1>0 Adv</td><td rowspan=1 colspan=1>DR</td><td rowspan=1 colspan=1>1 Adv</td><td rowspan=1 colspan=1>3 Adv</td><td rowspan=1 colspan=1>5 Adv</td></tr><tr><td rowspan=1 colspan=1>Mean Rew.% Change</td><td rowspan=1 colspan=1>1182</td><td rowspan=1 colspan=1>2662125</td><td rowspan=1 colspan=1>1094-7.4</td><td rowspan=1 colspan=1>203972.6</td><td rowspan=1 colspan=1>202171</td><td rowspan=1 colspan=1>472</td><td rowspan=1 colspan=1>1636246</td><td rowspan=1 colspan=1>91393.4</td><td rowspan=1 colspan=1>1598238</td><td rowspan=1 colspan=1>1565231</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>Validation</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=5>Test</td></tr><tr><td rowspan=1 colspan=1>Cheetah</td><td rowspan=1 colspan=1>0 Adv</td><td rowspan=1 colspan=1>DR</td><td rowspan=1 colspan=1>1 Adv</td><td rowspan=1 colspan=1>3 Adv</td><td rowspan=1 colspan=1>5 Adv</td><td rowspan=1 colspan=1>0 Adv</td><td rowspan=1 colspan=1>DR</td><td rowspan=1 colspan=1>1 Adv</td><td rowspan=1 colspan=1>3 Adv</td><td rowspan=1 colspan=1>5 Adv</td></tr><tr><td rowspan=1 colspan=1>Mean Rew.% Change</td><td rowspan=1 colspan=1>5659</td><td rowspan=1 colspan=1>3864-32</td><td rowspan=1 colspan=1>5593-1.2</td><td rowspan=1 colspan=1>59124.5</td><td rowspan=1 colspan=1>632311.7</td><td rowspan=1 colspan=1>5592</td><td rowspan=1 colspan=1>3656-35</td><td rowspan=1 colspan=1>56641.3</td><td rowspan=1 colspan=1>60468.1</td><td rowspan=1 colspan=1>640614.6</td></tr></table>
+
+Table 1: Average reward and $\%$ change from vanilla PPO (0 Adv) for Ant, Hopper, and Cheetah environments across ten seeds and across the validation (left) or holdout test set (right). Across all environments, we see consistently higher robustness using RAP than the minimax adversary. Most robust adversarial approach is bolded as domain randomization is an oracle and outside the class of perturbations that our adversaries can construct, and best result overall is italicized.
+
+validation set. This supports our hypothesis that a single adversary can actually lower the robustness of an agent.
+
+# 7 CONCLUSIONS AND FUTURE WORK
+
+In this work we demonstrate that the use of a single adversary to approximate the solution to a minimax problem does not consistently lead to improved robustness. We propose a solution through the use of multiple adversaries (RAP), and demonstrate that this provides robustness across a variety of robotics benchmarks. We also compare RAP with domain randomization and demonstrate that while DR can lead to a more robust policy, it requires careful parametrization of the domain we sample from to ensure robustness. RAP does not require this tuning, allowing for use in domains where appropriate tuning requires extensive prior knowledge or expertise.
+
+There are several open questions stemming from this work. While we empirically demonstrate the effects of RAP, we do not have a compelling theoretical understanding of why multiple adversaries are helping. Perhaps RAP helps approximate a mixed Nash equilibrium as discussed in Sec. 1 or perhaps population based training increases the likelihood that one of the adversaries is strong? Would the benefits of RAP disappear if a single adversary had the ability to represent mixed Nash?
+
+![](images/1d84bcf8c92d842243bff8a6f126f55153d7999c585ffce98b27de99a3f315e4.jpg)  
+Figure 4: Average reward across ten seeds on each validation set parametrization – friction coefficient on the x-axis and mass coefficient on the y-axis. DR refers to domain randomization and X Adv is an agent trained against X adversaries. Top row is Hopper and bottom row is Half Cheetah.
+
+There are some extensions of this work that we would like to pursue. We have looked at the robustness of our approach in simulated settings; future work will examine whether this robustness transfers to real-world settings. Additionally, our agents are currently memory-less and therefore cannot perform adversary identification; perhaps memory leads to a system-identification procedure that improves transfer performance. Our adversaries can also be viewed as forming a task distribution, allowing them to be used in continual learning approaches like MAML (Nagabandi et al., 2018) where domain randomization is frequently used to construct task distributions.
+
+# REFERENCES
+
+Rika Antonova, Silvia Cruciani, Christian Smith, and Danica Kragic. Reinforcement learning for pivoting task. arXiv preprint arXiv:1703.00472, 2017.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+
+Noam Brown and Tuomas Sandholm. Superhuman ai for multiplayer poker. Science, 365(6456): 885–890, 2019.
+
+Wojciech Marian Czarnecki, Gauthier Gidel, Brendan Tracey, Karl Tuyls, Shayegan Omidshafiei, David Balduzzi, and Max Jaderberg. Real world games look like spinning tops. arXiv preprint arXiv:2004.09468, 2020.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010.
+
+Parameswaran Kamalaruban, Yu-Ting Huang, Ya-Ping Hsieh, Paul Rolland, Cheng Shi, and Volkan Cevher. Robust reinforcement learning via adversarial training with langevin dynamics. arXiv preprint arXiv:2002.06063, 2020.
+
+Eric Liang, Richard Liaw, Philipp Moritz, Robert Nishihara, Roy Fox, Ken Goldberg, Joseph E Gonzalez, Michael I Jordan, and Ion Stoica. Rllib: Abstractions for distributed reinforcement learning. arXiv preprint arXiv:1712.09381, 2017.
+
+Shiau Hong Lim, Huan Xu, and Shie Mannor. Reinforcement learning in robust markov decision processes. In Advances in Neural Information Processing Systems, pp. 701–709, 2013.
+
+Bhairav Mehta, Manfred Diaz, Florian Golemo, Christopher J Pal, and Liam Paull. Active domain randomization. arXiv preprint arXiv:1904.04762, 2019.
+
+Anusha Nagabandi, Chelsea Finn, and Sergey Levine. Deep online learning via meta-learning: Continual adaptation for model-based rl. arXiv preprint arXiv:1812.07671, 2018.
+
+Arnab Nilim and Laurent El Ghaoui. Robust control of markov decision processes with uncertain transition matrices. Operations Research, 53(5):780–798, 2005.
+
+Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. In 2018 IEEE international conference on robotics and automation (ICRA), pp. 1–8. IEEE, 2018.
+
+Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2817–2826. JMLR. org, 2017.
+
+Martin L Puterman. Markov decision processes. Handbooks in operations research and management science, 2:331–434, 1990.
+
+Aravind Rajeswaran, Sarvjeet Ghotra, Balaraman Ravindran, and Sergey Levine. Epopt: Learning robust neural network policies using model ensembles. arXiv preprint arXiv:1610.01283, 2016.
+
+Fereshteh Sadeghi and Sergey Levine. Cad2rl: Real single-image flight without a single real image. arXiv preprint arXiv:1611.04201, 2016.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Aviv Tamar, Shie Mannor, and Huan Xu. Scaling up robust mdps using function approximation. In International Conference on Machine Learning, pp. 181–189, 2014.
+
+Yuval Tassa, Saran Tunyasuvunakool, Alistair Muldal, Yotam Doron, Siqi Liu, Steven Bohez, Josh Merel, Tom Erez, Timothy Lillicrap, and Nicolas Heess. dm_control: Software and tasks for continuous control. arXiv preprint arXiv:2006.12983, 2020.
+
+Chen Tessler, Yonathan Efroni, and Shie Mannor. Action robust reinforcement learning and applications in continuous control. arXiv preprint arXiv:1901.09184, 2019.
+
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 23–30. IEEE, 2017.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.
+
+Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019.
+
+Kemin Zhou and John Comstock Doyle. Essentials of robust control, volume 104. Prentice hall Upper Saddle River, NJ, 1998.
+
+# A FULL DESCRIPTION OF THE CONTINUOUS CONTROL MDPS
+
+We use the Mujoco ant, cheetah, and hopper environments as a test of the efficacy of our strategy versus the 0 adversary, 1 adversary, and domain randomization baselines. We use the Noisy Action Robust MDP formulation Tessler et al. (2019) for our adversary parametrization. If the normal system dynamics are
+
+$$
+s _ { k + 1 } = s _ { k } + f ( s _ { k } , a _ { k } ) \Delta t
+$$
+
+the system dynamics under the adversary are
+
+$$
+s _ { k + 1 } = s _ { k } + f ( s _ { k } , a _ { k } + a _ { k } ^ { \mathrm { a d v } } ) \Delta t
+$$
+
+where $a _ { k } ^ { \mathrm { a d v } }$ is the adversary action at time $\mathbf { k }$
+
+The notion here is that the adversary action is passed through the dynamics function and represents some additional set of dynamics. It is standard to clip actions within some boundary but for the above reason, we clip the agent and adversary actions separately. Otherwise, an agent would be able to limit the effect of the adversary by always taking actions at the bounds of its clipping range. The agent is clipped between $[ - 1 , 1 ]$ in the Hopper environment and the adversary is clipped between $[ - . 2 5 , . 2 5 ]$ .
+
+The MDP through which we train the agent policy is characterized by the following states, actions, and rewards:
+
+$s _ { t } ^ { \mathrm { a g e n t } } = \left[ o _ { t } , a _ { t } \right]$ where $o _ { t }$ is an observation returned by the environment, and $a _ { t }$ is the action taken by the agent.   
+We use the standard rewards provided by the OpenAI Gym Mujoco environments at https: //github.com/openai/gym/tree/master/gym/envs/mujoco. For the exact functions, please refer to the code at ANONYMIZED.   
+• $a _ { t } ^ { \mathrm { { a g e n t } } } \in [ a _ { \operatorname* { m i n } } , a _ { \operatorname* { m a x } } ] ^ { n } .$
+
+The MDP for adversary $i$ is the following:
+
+• st = st The adversary sees the same states as the agent. • The adversary reward is the negative of the agent reward. • $a _ { t } ^ { \mathrm { a d v } } \in \left[ a _ { \operatorname* { m i n } } ^ { \mathrm { a d v } } , a _ { \operatorname* { m a x } } ^ { \mathrm { a d v } } \right] ^ { n } .$
+
+For our domain randomization Hopper baseline, we use the following randomization: at each rollout, we scale the friction of all joints by a single value uniformly sampled from [0.7, 1.3]. We also randomly scale the mass of the ’torso’ link by a single value sampled from [0.7, 1.3]. For Half-Cheetah and Ant the range for friction is [0.1, 0.9] and for mass the range is [0.5, 1.5].
+
+![](images/5cd1da6df69e9225fe80e79a6c24582fcadaed14ae55d52a0794e39e182a76bf.jpg)  
+Figure 5: Average reward for Hopper across varying adversary number.
+
+# B INCREASING ADVERSARY POOL SIZE
+
+We investigate whether RAP is robust to adversary number as this would be a useful property to minimize hyperparameter search. Here we hypothesize that while having more adversaries can represent a wider range of dynamics to learn to be robust to, we expect there to be diminishing returns due to the decreased batch size that each adversary receives (total number of environment steps is held constant across all training variations). We expect decreasing batch size to lead to worse agent policies since the batch will contain under-trained adversary policies. We cap the number of adversaries at eleven as our machines ran out of memory at this value. We run ten seeds for every adversary value and Fig. 5 shows the results for Hopper. Agent robustness on the test set increases monotonically up to three adversaries and roughly begins to decrease after that point. This suggests that a trade-off between adversary number and performance exists although we do not definitively show that diminishing batch sizes is the source of this trade-off. However, we observe in Fig. 6 that both three and five adversaries perform well across all studied Mujoco domains.
+
+![](images/2b6de1d61200577190acbce8d0f96638451a60257d0c7994ae5d91b9ac0d29f6.jpg)  
+Figure 6: Average reward for Ant, Hopper, and Cheetah environments across ten seeds and across the validation set (top row) and across the holdout test set (bottom row). We compare vanilla PPO, the domain randomization oracle, and the minimax adversary against RAP of size three and five. Bars represent the mean and the arms represent the std. deviation. Both are computed over 20 rollouts for each test-set sample. The std. deviation for the test set are not reported here for visual clarity due to the large variation in holdout test difficulty.
+
+# C HOLDOUT TESTS
+
+In this section we describe in detail all of the holdout tests used.
+
+![](images/605f064acbf9c68e211b615e6c737becefbfb0068c3648433e24bda6d93bfae9.jpg)  
+Figure 7: Labelled Body Segments of Hopper Table 2: Hopper Holdout Test Descriptions
+
+<table><tr><td>Test</td><td>Body with Friction Coeff 1.3</td><td>Body with Friction Coeff 0.7</td></tr><tr><td>A</td><td>Torso,Leg</td><td>Floor, Thigh,Foot</td></tr><tr><td>B</td><td>Floor, Thigh</td><td>Torso,Leg,Foot</td></tr><tr><td>C</td><td>Foot,Leg</td><td>Floor, Torso, Thigh</td></tr><tr><td>D</td><td>Torso,Thigh,Floor</td><td>Foot,Leg</td></tr><tr><td>E</td><td>Torso,Foot</td><td>Floor, Thigh,Leg</td></tr><tr><td>F</td><td>Floor, Thigh,Leg</td><td>Torso,Foot</td></tr><tr><td>G</td><td>Floor, Foot</td><td>Torso, Thigh,Leg</td></tr><tr><td>H</td><td>Thigh,Leg</td><td>Floor, Torso,Foot</td></tr></table>
+
+# C.1 HOPPER
+
+The Mujoco geom properties that we modified are attached to a particular body and determine its appearance and collision properties. For the Mujoco holdout transfer tests we pick a subset of the hopper ‘geom’ elements and scale the contact friction values by maximum friction coefficient, 1.3. Likewise, for the rest of the ‘geom’ elements, we scale the contact friction by the minimum value of 0.7. The body geoms and their names are visible in Fig. 7.
+
+The exact combinations and the corresponding test name are indicated in Table 2 for Hopper.
+
+# C.2 CHEETAH
+
+The Mujoco geom properties that we modified are attached to a particular body and determine its appearance and collision properties. For the Mujoco holdout transfer tests we pick a subset of the
+
+![](images/5abdb47e4a61c933625a47906afaeff5f7fe5e303e78cc6764643c2582e6fc57.jpg)  
+Figure 8: Labelled Body Segments of Cheetah
+
+Table 3: Cheetah Holdout Test Descriptions. Joints in the table receive the maximum friction coefficient of 0.9. Joints not indicated have friction coefficient 0.1   
+
+<table><tr><td rowspan=1 colspan=1>Test</td><td rowspan=1 colspan=1>Geom with Friction Coeff 0.9</td></tr><tr><td rowspan=1 colspan=1>A</td><td rowspan=6 colspan=1>Torso,Head,FthighFloor,Head,FshinBthigh,Bshin,BfootFloor, Torso,HeadFloor,Bshin,FfootBthigh,Bfoot,Ffoot</td></tr><tr><td rowspan=1 colspan=1>B</td></tr><tr><td rowspan=1 colspan=1>C</td></tr><tr><td rowspan=1 colspan=1>D</td><td rowspan=1 colspan=1>Floor, Torso,Head</td></tr><tr><td rowspan=1 colspan=1>E</td><td rowspan=1 colspan=1>Floor,Bshin,Ffoot</td></tr><tr><td rowspan=1 colspan=1>F</td></tr><tr><td rowspan=1 colspan=1>G</td><td rowspan=1 colspan=1>Bthigh,Fthigh,Fshin</td></tr><tr><td rowspan=1 colspan=1>H</td><td rowspan=1 colspan=1>Head,Fshin,Ffoot</td></tr></table>
+
+![](images/36982b9c4d7582f019aad9a49a156d939d5e9e0b25126dee03e2d775d2099388.jpg)  
+Figure 9: Labelled Body Segments of Ant
+
+cheetah ‘geom’ elements and scale the contact friction values by maximum friction coefficient, 0.9. Likewise, for the rest of the ‘geom’ elements, we scale the contact friction by the minimum value of 0.1. The body geoms and their names are visible in Fig. 8.
+
+The exact combinations and the corresponding test name are indicated in Table 4 for Hopper.
+
+# C.3 ANT
+
+We will use torso to indicate the head piece, leg to refer to one of the four legs that contact the ground, and ’aux’ to indicate the geom that connects the leg to the torso. Since the ant is symmetric we adopt a convention that two of the legs are front-left and front-right and two legs are back-left and back-right. Fig. 9 depicts the convention. For the Mujoco holdout transfer tests we pick a subset of the ant ‘geom’ elements and scale the contact friction values by maximum friction coefficient, 0.9. Likewise, for the rest of the ‘geom’ elements, we scale the contact friction by the minimum value of 0.1.
+
+Table 4: Ant Holdout Test Descriptions. Joints in the table receive the maximum friction coefficient of 0.9. Joints not indicated have friction coefficient 0.1   
+
+<table><tr><td>Test</td><td>GeomwithFriction Coeff 0.9</td></tr><tr><td>A B C D</td><td>Front-Leg-Left,Aux-Front-Left,Aux-Back-Left Torso,Aux-Front-Left,Back-Leg-Right Front-Leg-Right, Aux-Front-Right,Back-Leg-Left</td></tr><tr><td>E F</td><td>Torso,Front-Leg-Left,Aux-Front-Left Front-Leg-Left, Aux-Front-Right, Aux-Back-Right Front-Leg-Right, Back-Leg-Left,Aux-Back-Right</td></tr><tr><td>G H</td><td>Front-Leg-Left,Aux-Back-Left,Back-Leg-Right Aux-Front-Left,Back-Leg-Right,Aux-Back-Right</td></tr></table>
+
+Table 5: Results on holdout tests for each of the tested approaches for Hopper. Bolded values have the highest mean   
+
+<table><tr><td>Test Name</td><td>0 Adv</td><td>1 Adv</td><td>3 Adv</td><td>Five Adv</td><td>Domain Rand</td></tr><tr><td>Test A</td><td>410±140</td><td>1170 ± 570</td><td>2210±630</td><td>2090±920</td><td>1610±310</td></tr><tr><td>Test B</td><td>430 ± 150</td><td>1160 ± 540</td><td>2240 ± 730</td><td>2200 ± 880</td><td>1610 ± 290</td></tr><tr><td>Test C</td><td>560 ±120</td><td>490 ± 150</td><td>610± 250</td><td>580 ±120</td><td>1660 ± 260</td></tr><tr><td>Test D</td><td>420 ±150</td><td>1140 ± 560</td><td>2220 ±680</td><td>2130 ± 890</td><td>1612 ± 360</td></tr><tr><td>TestE</td><td>550 ±120</td><td>500 ± 150</td><td>600 ± 240</td><td>590 ±120</td><td>1680 ± 280</td></tr><tr><td>Test F</td><td>420 ±150</td><td>1200 ± 620</td><td>2080 ± 750</td><td>2160 ± 890</td><td>1650 ± 360</td></tr><tr><td>Test H</td><td>560 ± 130</td><td>500 ±140</td><td>600 ± 230</td><td>600 ±140</td><td>1710 ± 370</td></tr><tr><td>Test G</td><td>420 ±150</td><td>1160 ± 590</td><td>2210 ±680</td><td>2160 ± 920</td><td>1560 ± 340</td></tr></table>
+
+<table><tr><td>Test Name</td><td>0 Adv</td><td>1 Adv</td><td>3 Adv</td><td>Five Adv</td><td>Domain Rand</td></tr><tr><td>Test A</td><td>4400±2160</td><td>5110± 730</td><td>4960±1280</td><td>5560±1060</td><td>2800±1540</td></tr><tr><td>Test B</td><td>6020 ± 880</td><td>5980 ± 290</td><td>6440 ± 1620</td><td>6880±1090</td><td>3340 ± 600</td></tr><tr><td>Test C</td><td>5880 ± 1030</td><td>5730 ± 640</td><td>6740±1190</td><td>6410 ± 790</td><td>4280± 240</td></tr><tr><td>Test D</td><td>5990 ± 940</td><td>5960 ± 260</td><td>6430 ± 1610</td><td>6880±1090</td><td>3360 ± 570</td></tr><tr><td>TestE</td><td>5570± 570</td><td>5670 ± 290</td><td>5800 ± 1316</td><td>6530±1250</td><td>3720 ± 540</td></tr><tr><td>TestF</td><td>5870± 750</td><td>5800 ± 350</td><td>6500 ± 1100</td><td>6770±1070</td><td>3810 ± 330</td></tr><tr><td>Test H</td><td>5310 ± 1060</td><td>5270 ± 700</td><td>5610 ± 720</td><td>5660 ± 980</td><td>4560 ± 560</td></tr><tr><td>Test G</td><td>5710 ± 650</td><td>5790 ± 300</td><td>5890 ± 1240</td><td>6560±1240</td><td>3380 ± 720</td></tr></table>
+
+Table 6: Results on holdout tests for each of the tested approaches for Half Cheetah. Bolded values have the highest mean
+
+The exact combinations and the corresponding test name are indicated in Table 4 for Hopper.
+
+# D RESULTS
+
+Here we recompute the values of all the results and display them with appropriate standard deviations in tabular form.
+
+There was not space for the ant validation set results so they are reproduced here.
+
+<table><tr><td>Test Name</td><td>0 Adv</td><td>1 Adv</td><td>3 Adv</td><td>Five Adv</td><td>Domain Rand</td></tr><tr><td>Test A</td><td>590± 650</td><td>730± 630</td><td>600±440</td><td>560± 580</td><td>900±580</td></tr><tr><td>Test B</td><td>5240 ± 280</td><td>5530 ± 200</td><td>5770 ± 100</td><td>5710 ±180</td><td>6150 ±180</td></tr><tr><td>Test C</td><td>750± 820</td><td>1090 ± 660</td><td>1160 ± 540</td><td>1040 ± 760</td><td>1370 ± 800</td></tr><tr><td>Test D</td><td>5220 ± 300</td><td>5560 ± 220</td><td>5770 ± 90</td><td>5660 ± 190</td><td>6120 ±180</td></tr><tr><td>TestE</td><td>5270± 290</td><td>5570 ± 210</td><td>5770±100</td><td>5660± 220</td><td>6140 ±150</td></tr><tr><td>TestF</td><td>780 ±860</td><td>1160 ± 570</td><td>1120 ± 580</td><td>1140 ± 870</td><td>1390 ± 750</td></tr><tr><td>Test H</td><td>130 ± 290</td><td>420 ± 300</td><td>210 ± 220</td><td>160 ± 270</td><td>700 ± 560</td></tr><tr><td>Test G</td><td>5290± 280</td><td>5560 ± 220</td><td>5770 ±100</td><td>5700 ± 190</td><td>6150 ±160</td></tr></table>
+
+Table 7: Results on holdout tests for each of the tested approaches for Ant. Bolded values have the highest mean
+
+![](images/93aba988bfcf02e081e4bfb58ca181b5da25988c41f8aa7a646b3f519db5b5c1.jpg)  
+Figure 10: Ant Heatmap: Average reward across 10 seeds on each validation set (mass, friction) parametrization.
+
+# E CHALLENGES OF DOMAIN RANDOMIZATION
+
+In our experiments, we find that naive parametrization of domain randomization can result in a brittle policy, even when evaluated on the same distribution it was trained on.
+
+# Effect of Domain Randomization Parametrization
+
+From Fig. 6, we see that in the Ant and Hopper domains, the DR oracle achieves the highest transfer reward in the validation set as expected since the DR oracle is trained directly on the validation set. Interestingly, we found that the domain randomization policy performed much worse on the Half Cheetah environment, despite having access to the mass and friction coefficients during training. Looking at the performance for each mass and friction combination in Fig. 11, we found that the DR agent was able to perform much better at the low friction coefficients and learned to prioritize those values at the cost of significantly worse performance on average. This highlights a potential issue with domain randomization: while training across a wide variety of dynamics parameters can increase robustness, naive parametrizations can cause the policy to exploit subsets of the randomized domain and lead to a brittle policy. This is a problem inherent to the expectation across domains that is used in domain randomization; if some subset of randomizations have sufficiently high reward the agent will prioritize performance on those at the expense of robustness.
+
+We hypothesize that this is due to the DR objective in Eq. 2 optimizing in expectation over the sampling range. To test this, we created a separate range of ‘good’ friction parameters [0.5, 1.5] and compared the robustness of a DR policy trained with ‘good‘ range against a DR policy trained with ‘bad’ range [0.1, 0.9] in Fig. 11. Here we see that a ‘good’ parametrization leads to the expected result where domain randomization is the most robust. We observe that domain randomization underperforms adversarial training on the validation set despite the validation set literally constituting the training set for domain randomization. This suggests that underlying optimization difficulties caused by significant variations in reward scaling are partially to blame for the poor performance of domain randomization. Notably, the adversary-based methods are not susceptible to the same parametrization issues.
+
+# Alternative DR policy architecture
+
+As discussed above and also identified in Rajeswaran et al. (2016), the expectation across randomizations that is used in domain randomization causes it to prioritize a policy that performs well in a high-reward subset of the randomization domains. This is harmless when domain randomization is used for randomizations of state, such as color, where all the randomization environments have the same expected reward, but has more pernicious effects in dynamics randomizations. Consider a set of $\cdot$ randomization environments, $N - 1$ of which have reward $\cdot$ and one of which has has reward $R _ { \mathrm { h i g h } }$ where $\_$ . If the agent cannot identify which of the randomization environments it is in, the intuitively optimal solution is to pick the policy that optimizes the high reward environment. One possible way out of the quandary is to use an agent that has some memory, such as an LSTM-based policy, thus giving the possibility of identifying which environment the agent is in and deploying the appropriate response. However, if $R _ { \mathrm { h i g h } }$ is sufficiently large and there is some reduction in reward associated with performing the system-identification necessary to identify the randomization, then the agent will not perform the system identification and will prioritize achieving $R _ { \mathrm { h i g h } }$ . As an illustration of this challenge, Fig. 12 compares the results of domain randomization on the half-cheetah environment with and without memory. In the memory case, we use a 64 unit LSTM. As can be seen, there is an improvement in the ability of the domain randomized policy to perform well on the full range of low-friction / high mass values, but the improved performance does not extend to higher friction values. In fact, the performance contrast is enhanced even further as the policy does a good deal worse on the high friction values than the case without memory.
+
+![](images/2f1466b54cca32e75f2c948eed73043d00c81b16f9d9b66ac593ede7c721b0c6.jpg)  
+Figure 11: Average reward for Half Cheetah environment across ten seeds. Top row shows the average reward when trained with a ‘bad’ friction parametrization which lead to DR not learning a robust agent policy, and bottom row shows the average reward when trained with a ‘good’ friction parametrization.
+
+![](images/1fa1062e557af107893e21857ca71a2f5d7e1bad3d8dc6f58531dbab9efe0af1.jpg)  
+Figure 12: Left: heatmap of the performance of the half-cheetah domain randomized policy across the friction and mass value grid. Right: Left: heatmap of the performance of the half-cheetah domain randomized policy across the friction and mass value grid where the agent policy is an LSTM.
+
+# F ADDITIONAL EXPERIMENTS
+
+Here we outline a few more experiments we ran that demonstrate the value of additional adversaries. We run the following tasks:
+
+# F.1 DEEPMIND CONTROL CATCH
+
+This task uses the same Markov Decision Process described in Sec. A. The challenge (Tassa et al., 2020), pictured in Fig. 13, is to get the ball to fall inside the cup. As in the other continuous control tasks, we apply the adversary to the actions of the agents (which is controlling the cup). We then test on variations of the mass of both the ball and the cup. The heatmaps for this task are presented in Fig. 14 where the 3 adversary case provides a slight improvement in the robustness region relative to the 1 adversary case.
+
+![](images/a8e5c4561daeb917f6e01096b4089b4c897d463f6833626f2061f4df4636da14.jpg)  
+Figure 13: The DeepMind Control catch task. The cup moves around and attempts to get the ball to fall inside.
+
+![](images/7c402a3092d0eab85f3b65d86519a11163a99cdd8467dfa1e78a0f709a9b4b44.jpg)  
+Figure 14: (Top left) 0 adversary, (top right) 1 adversary, (bottom left) 3 adversary, (bottom right) 5 adversaries for variations of cup and ball mass.
+
+# F.2 MULTI-ARMED BERNOULLI BANDITS
+
+As an illustrative example, we examine a multi-armed stochastic bandit, a problem widely studied in reinforcement learning literature. Generally, successful strategies for multi-arm bandit problems involve successfully balancing the exploration across arms and exploiting the ’best’ arm. A "robust" strategy should have vanishing regret as the time horizon goes to infinity. We construct a 10-armed bandit where each arm $\cdot$ is parametrized by a value $\cdot$ where p is the probability of that arm returning
+
+1. The goal of the agent is to minimize total cumulative regret $R _ { n }$ over a horizon of $n$ steps:
+
+$$
+R _ { n } = n \operatorname* { m a x } _ { i } \mu _ { i } - \mathbb { E } \left[ \sum _ { t = 0 } ^ { n } a _ { t } \right]
+$$
+
+where $\cdot$ corresponds to picking a particular arm. At each step, the agent is given an observation buffer of stacked frames consisting of all previous (action, reward) pairs padded with zeros to keep the length fixed. The adversary has a horizon of 1; at time-step zero it receives an observation of 0 and outputs the probability for each arm. At the termination of the horizon the adversary receives the negative of the cumulative agent reward. For our domain randomization baseline we use uniform sampling of the $\cdot$ value for each arm. We chose a horizon length of $\cdot$ steps. The MDP of the agent is characterized as follows:
+
+$$
+\begin{array} { r l } & { \bullet s _ { t } = \left[ 0 ^ { n * ( T - t ) \times 1 } , r _ { t } , a _ { t } , r _ { t - 1 } , a _ { t - 1 } , \dotsc , \dotsc , r _ { 0 } , a _ { 0 } \right] } \\ & { \bullet r _ { t } = X ( a _ { i } ) - \operatorname* { m a x } _ { i } \mu _ { i } } \\ & { \bullet a _ { t } ^ { \mathrm { a g e n t } } \in 0 \dots . . 9 } \end{array}
+$$
+
+At each step, the agent is given an observation buffer of stacked frames consisting of all previous (action, reward) pairs. The buffer matching the horizon length is padded with zeros. For each training step, the agent receives a reward of the negative expected regret. We set up the adversary problem as an MDP with a horizon of 1.
+
+$$
+\begin{array} { r l } & { \bullet s _ { t } = [ 0 . 0 ] } \\ & { \bullet r = - \sum _ { i = 1 } ^ { T } r _ { t } } \\ & { \bullet a ^ { \mathrm { a d v } } \in [ 0 , 1 ] ^ { 1 0 } } \end{array}
+$$
+
+During adversarial training, we sample a random adversary at the beginning of each rollout, and allow it to pick $\cdot$ values that are then shuffled randomly and then assigned to each arm (this is to prevent the agent from deterministically knowing which arm has which $p$ value). The adversary is always given an observation of a vector of zeros and is rewarded once at the end of the rollout. We also construct a hold-out test of two bandit examples which we colloquially refer to as "evenly spread" and "one good arm." In "evenly spread", the arms, going from 1 to 10 have evenly spaced probabilities in steps of $-$ . In "one good arm" 9 arms have probability 0.1 and one arm has probability 0.9. As our policy for the agent, we use a Gated Recurrent Unit network with hidden size 256.
+
+An interesting feature of the bandit task is that it makes clear that the single adversary approach corresponds to training on a single, adversarially constructed bandit instance. Surprisingly, as indicated in Fig. 15, this does not perform terribly on our two holdout tasks. However, there is a clear improvement on both tasks in the four adversary case. All adversarial approaches outperform an Upper Confidence Bound-based expert (shown in red). Interestingly, domain randomization, which had superficially good reward at training time, completely fails on the "one good arm" holdout task. This suggests another possible failure mode of domain randomization where in high dimensions uniform sampling may just fail to yield interesting training tasks. Finally, we note that since the upper confidence approach only tries to minimize regret asymptotically, our outperforming it may simply be due to our relatively short horizon; we simply provide it as a baseline.
+
+# G COST AND HYPERPARAMETERS
+
+Here we reproduce the hyperparameters we used in each experiment and compute the expected runtime and cost of each experiment. Numbers indicated in $\{ \}$ were each used for one run. Otherwise the parameter was kept fixed at the indicated value.
+
+# G.1 HYPERPARAMETERS
+
+For Mujoco the hyperparameters are:
+
+• Learning rate:
+
+![](images/10c84f08a455e0438147360746f5db876a7b38a5bd0dc152fb9959898e8e7f21.jpg)  
+Figure 15: Two transfer tests for the bandit task. On both tasks the 4 adversary case has improved performance relative to RARL while domain randomization performs terribly on all tasks. Bars indicate one std. deviation of the performance over 100 trials.
+
+– $- \ \{ . 0 0 0 3 , . 0 0 0 5 \}$ for half cheetah – $- \ \{ . 0 0 0 5 , . 0 0 0 0 5 \}$ for hopper and ant • Generalized Advantage Estimation $\lambda$ – $\cdot \ \{ 0 . 9 , 0 . 9 5 , 1 . 0 \}$ for half cheetah – $\textbf { - } \{ 0 . 5 , 0 . 9 , 1 . 0 \}$ for hopper and ant • Discount factor $\gamma = 0 . 9 9 5$ • Training batch size: 100000 • SGD minibatch size: 640 • Number of SGD steps per iteration: 10 • Number of iterations: 700 • We set the seed to 0 for all hyperparameter runs. • The maximum horizon is 1000 steps.
+
+For the validation across seeds we used 10 seeds ranging from 0 to 9. All other hyperparameters are the default values in RLlib Liang et al. (2017) 0.8.0
+
+# G.2 COST
+
+For all of our experiments we used AWS EC2 c4.8xlarge instances which come with 36 virtual CPUs. For the Mujoco experiments, we use 2 nodes and 11 CPUs per hyper-parameter, leading to one full hyper-parameter sweep fitting onto the 72 CPUs. We run the following set of experiments and ablations, each of which takes 8 hours.
+
+• 0 adversaries   
+• 1 adversary   
+• 3 adversaries   
+• 5 adversaries   
+• Domain randomization
+
+for a total of 5 experiments for each of Hopper, Cheetah, Ant. For the best hyperparameters and each experiment listed above we run a seed search with 6 CPUs used per-seed, a process which takes about 12 hours. This leads to a total of $2 * 8 * 5 * 3 + 2 * 1 2 * 3 * 5 = 6 0 0$ node hours and $3 6 * 6 0 0 \approx 2 2 0 0 0$
+
+![](images/51784079b613fc70140ca432558c816b83581d3fff49c302e361b4ae698adc77.jpg)  
+Figure 16: Wall-clock time vs. reward for varying numbers of adversaries. Despite varying adversary numbers, the wall-clock time of 1, 3, 5, and 7 adversary runs are all the same.
+
+CPU hours. At a cost of $\approx 0 . 3$ dollars per node per hour for EC2 spot instances, this gives $\approx 1 8 0$ dollars to fully reproduce our results for this experiment. If the chosen hyperparameters are used and only the seeds are sweep, this is $\approx 1 0 0$ dollars.
+
+# G.3 RUN TIME AND SAMPLE COMPLEXITY
+
+Here we briefly analyze the expected run-time of our algorithms. While there is an additional cost for adding a single adversary equal to the sum of the cost of computing gradients at train time and actions at run-time for an additional agent, there is no additional cost for adding additional adversaries. Since we divide the total set of samples per iteration amongst the adversaries, we compute approximately the same number of gradients and actions in the many-adversary case as we do in the single adversary case. In Fig. 16 plot of reward vs. wall-clock time supports this argument: the 0 adversary case runs the fastest but all the different adversary numbers complete 700 iterations of training in approximately the same amount of time. Additionally, Fig. 17 demonstrates that there is some variation in sample complexity but the trend is not consistent across adversary number.
+
+# G.4 CODE
+
+Our code is available at ANONYMIZED. For our reinforcement learning code-base we used RLlib Liang et al. (2017) version 0.8.0 and did not make any custom modifications to the library.
+
+# H PURE NASH EQUILIBRIA DO NOT NECESSARILY EXIST
+
+While there are canonical examples of games in which pure Nash equilibria do not exist such as rock-paper-scissors, we are not aware one for sequential games with continuous actions. Tessler et al. (2019) contains an example of a simple, horizon 1 MDP where duality is not satisfied. The pure minimax solution does not equal the value of the pure maximin solution and a greater value can be achieved by randomizing one of the policies showing that there is no pure equilibrium.
+
+![](images/76db3eab1b17aa1cf53f71a7a86b4799a3cb4c6122af7d4b17aaedda341e44ed.jpg)  
+Figure 17: Iterations vs. reward for varying numbers of adversaries. Despite varying adversary numbers, the wall-clock time of 1, 3, 5, and 7 adversary runs are all the same.

parse/train/IQgbmaoDDjd/IQgbmaoDDjd.md

@@ -0,0 +1,455 @@
+# Cooperative Multi-Agent Reinforcement Learning with Sequential Credit Assignment
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Centralized training with decentralized execution is a standard paradigm for coop  
+2 erative multi-agent reinforcement learning (MARL), with credit assignment being   
+3 a major challenge. In this paper, we propose a cooperative MARL method with   
+4 sequential credit assignment (SeCA) that deduces each agent’s contribution to the   
+5 team’s success one by one to learn better cooperation. We first present a sequential   
+6 MARL framework, under which we introduce a new counterfactual advantage to   
+7 evaluate each agent based on its preceding agents’ actions in a specific sequence.   
+8 As this credit assignment sequence tremendously impacts the performance, we   
+9 further present a sequence adjustment algorithm utilizing integrated gradients. It   
+10 dynamically modifies the sequence among agents according to their contribution   
+11 to the team. SeCA employs a network which either estimates the Q value for   
+12 training the centralized critic or deduces the proposed advantage of each agent for   
+13 decentralized policy learning. Our method is evaluated on a challenging set of   
+14 StarCraft II micromanagement tasks and achieves state-of-the-art performance.
+
+# 15 1 Introduction
+
+16 Cooperative multi-agent reinforcement learning (MARL) is a helpful tool in numerous applications   
+17 such as robot swarm control [9], autonomous vehicle coordination [3], network routing [36], and   
+18 productivity optimization [37]. This kind of problem where agents learn coordinated policies to   
+19 optimize the global reward has been extensively studied in recent years [7, 19, 18, 38, 8].   
+20 One natural way of addressing the cooperative MARL problem is the centralized approach, which   
+21 treats the team as a single actor with a joint action space. Although we can trivially apply single-agent   
+22 reinforcement learning algorithms to such settings, it usually does not scale well because the size of   
+23 the joint action space grows exponentially with the number of agents. Besides, it is not applicable   
+24 in real-world settings due to the inherent constraints on agent observability and communication.   
+25 An alternative approach is to learn decentralized policies by independently training agents based   
+26 on their local observations, but simultaneous exploration often brings non-stationarity that causes   
+27 unstable learning and difficulties in convergence. As a result, the majority of work on MARL   
+28 follows the centralized training with decentralized execution (CTDE) paradigm [17, 10, 22, 6], where   
+29 decentralized policies can access extra state information during training.   
+30 A crucial challenge of the CTDE paradigm in cooperative settings is to correctly deduce each agent’s   
+31 contribution to the team’s success, also known as the multi-agent credit assignment problem [4].   
+32 Existing methods can be classified as implicit and explicit credit assignment [39]. Previous implicit   
+33 methods often deduce all agents’ contributions by representing the global state-action value as an   
+34 aggregation of each agent’s state-action value [26, 22, 12, 24, 21, 29] and assigning the shared rewards   
+35 to each agent according to the joint action at one time. In this way, these methods avoid the complex   
+36 interaction analysis and instead fit these cooperation relationships by neural networks. However,   
+37 implicit methods often face limitations in expressiveness, and their extensions to continuous action   
+38 spaces may require additional strategies [39].   
+39 On the other hand, recognized explicit approaches calculate difference rewards [34] against a certain   
+40 reward baseline [28, 20, 6]. However, in cooperative MARL, evaluating any agent’s action requires   
+41 considering the actions of all agents, so it is often difficult to determine the impact a particular agent’s   
+42 behavior has on the team when we have not assessed other agents’ actions. In other words, we can   
+43 not say that a single agent’s action is bad if the team receives a small reward because the shared   
+44 reward is not decided only by this agent’s behavior. Maybe its action is actually good in that state.   
+45 This paper presents a sequential credit assignment SeCA to evaluate individual agent actions explicitly   
+46 and sequentially. Our motivation is to address the drawbacks of implicit methods that neglect the   
+47 cooperation between agents or simply leave it to neural networks and further improve explicit credit   
+48 assignment. In summary, we face two main challenges to learn a better explicit credit assignment: (1)   
+49 how to alleviate the problem that it is hard to accurately deduce the contribution of one agent without   
+50 previously assessing all the others’ action, and (2) how to evaluate agents better in an explicit way.   
+51 To deal with (1), we introduce a sequential MARL framework. As mentioned above, without assessing   
+52 the behaviors of other agents, we would never be able to evaluate a given agent’s action accurately.   
+53 However, we point out in this paper that some agents are less affected by such influences than others,   
+54 and we can first assign credit to them. For instance, evaluating a staff’s action needs to take the   
+55 CEO’s command or action into consideration, while the former has little importance in assessing the   
+56 CEO. Thus, we could evaluate the CEO first without considering the staff’s behavior and then analyze   
+57 the staff based on the CEO’s action. We fully consider the action coordination between agents and   
+58 explicitly deduce contribution to them one by one according to a particular order, so as to make up   
+59 for the disadvantage of implicit methods that the cooperation is only inexplicably fitted by neural   
+60 networks. Intuitively, the order significantly impacts the overall performance, so we further propose   
+61 an algorithm to adjust the sequence dynamically through integrated gradients [25].   
+62 As for (2), we compute an advantage function for each agent to attribute agent contributions explicitly.   
+63 COMA [6] is a representative method that computes a baseline for each agent to reason about   
+64 counterfactuals in which only one agent $a$ ’s action changes, so its evaluation of $a$ ’s action is based on   
+65 the joint action $\mathbf { u } ^ { - a }$ of other agents. In other words, the policy gradient of COMA only encourages   
+66 agent $a$ to learn in the direction that benefits the team while other agents are acting $\mathbf { u } ^ { - a }$ , but the   
+67 others’ actions are not necessarily $\mathbf { u } ^ { - a }$ when executing. Unlike COMA, we focus more on the action   
+68 coordination among agents and propose a new advantage under the proposed sequential framework.   
+69 We summarize the contributions of this paper as follows: (1) We propose a sequential MARL   
+70 framework in Section 3.2; (2) Under this framework, we introduce a sequential advantage function   
+71 for each agent to guide their learning explicitly in Section 3.3. We further prove that the sequential   
+72 credit assignment we proposed achieves additive advantage-decomposition. (3) We present a sequence   
+73 adjustment algorithm based on integrated gradients to modify the credit assignment order dynamically   
+74 in Section 3.4. This algorithm alleviates the impact caused by the sequence’s randomness and helps   
+75 achieve competitive performance on a challenging set of StarCraft II micromanagement tasks [23].
+
+# 76 2 Related Work
+
+77 Explicit credit assignment gives valuable insights into agent actions’ contributions to the shared   
+78 team reward and substantially promotes policy optimization. The representative method COMA [6]   
+79 utilizes a counterfactual baseline that marginalizes out a single agent’s action while keeping the other   
+80 agents’ actions fixed to calculate the advantage function. However, the advantage evaluates a single   
+81 agent’s action based on the other agents’ current behaviors and ignores different action combinations.   
+82 SQDDPG [30] distributes the global reward reflecting each agent’s contribution through Shapley   
+83 Value. Although SQDDPG provides a theoretically justified framework, its assumption on the   
+84 observability and convex game makes it impractical and performs poorly in complex environments.   
+85 Implicit methods are a more common way when addressing the credit assignment challenge. Among   
+86 them, LICA [39] is a policy-based method, which learns an end-to-end differentiable optimization   
+87 where it trains a hypernetwork that maps the state into a set of weights which, in turn, maps the   
+88 action policies into the Q estimate. On the other hand, value-based methods often represent the   
+89 global state-action value as an aggregation of the individual values. The value decomposition is linear   
+90 in the earlier work VDN [26], and it ignores the state information. QMIX [22] learns a non-linear   
+91 mixing network with the global state and maps the individual state-action values into the joint Q value   
+92 estimate. Although QMIX performs well in various environments, it still faces the mixing network’s   
+93 monotonicity constraint limitation. QTRAN [24] further avoids the representation limitations by   
+94 using linear constraints between individual utilities and the global state-action value. It guarantees   
+95 optimal decentralization, but its constraints are computationally intractable, and the relaxations often   
+96 lead to unsatisfied performance. QPLEX [29] decomposes Q values following the dueling structure,   
+97 transferring the monotonicity condition from Q values to advantage values. QPD [35] leverages the   
+98 integrated gradient attribution technique to decompose global Q values along trajectory paths based   
+99 on the assumption that an agent’s local reward is linearly correlated with its contribution to the team.
+
+# 3 Methods
+
+# 3.1 Preliminaries
+
+Notations. This work considers a fully cooperative multi-agent task with $n$ agents $\mathcal { A } = \{ 1 , . . . , n \}$ as a Dec-POMDP [16] defined by a tuple $\mathbf { \bar {  { G } } } = ( S , U , P , \bar { r } , Z , O , n , \gamma )$ . The environment has a true state $s \in S$ . Each agent $a$ chooses an action $u _ { t } ^ { a }$ from its action space $U$ at each timestep $t$ and forms a joint action $\mathbf { u } _ { t }$ that induces a transition in the environment according to the state transition function $P ( s _ { t + 1 } | s _ { t } , \mathbf { u } _ { t } ) : S \times U ^ { n } \times S  [ 0 , 1 ] .$ . The agents share the same reward function $r ( s , \mathbf { u } ) : S \times u ^ { n }  \mathbb { R }$ , and $\gamma \in [ 0 , 1 )$ is the discount factor. We consider partially observable scenarios in which agent $a$ acquires its local observation $z ^ { a } \in Z$ drawn from $O ( s _ { t } , a ) : S \times \mathcal { A } \to Z$ Each agent has an action-observation history $\tau ^ { a } \in T \equiv ( Z \times U ) ^ { * }$ , on which it conditions a policy $\pi ^ { a } ( u ^ { a } | \bar { \tau } ^ { a } ) : T \times U \to [ 0 , 1 ]$ . We denote joint quantities over agents in bold and joint quantities over agents other than a given agent $a$ with the superscript $- a$ .
+
+112 Integrated Gradients. Many works aim to attribute the predictions of deep networks to their input   
+113 features [1, 15, 2]. As one of them, integrated gradients [25] aggregates the gradients along the inputs   
+114 that fall on the lines between the baseline $\vec { b }$ and the input ${ \vec { x } } = ( x _ { 1 } , . . . , x _ { j } , . . . , x _ { d } )$ . It explains how   
+115 much one feature affects the deep network output $F$ while changing from $F ( \vec { b } )$ to $F ( \vec { x } )$ along a   
+116 path between $\vec { b }$ and $\vec { x }$ . Given a path function $\tau ( \alpha )$ with $\alpha \in [ 0 , 1 ]$ specifying a path from baseline   
+117 $\tau ( 0 ) = \vec { b }$ to the input $\tau ( 1 ) = \vec { x }$ , then integrated gradients along the $j ^ { t h }$ dimension is acquired by:
+
+$$
+c _ { j } = \mathrm { P a t h I G } _ { j } ^ { \tau } ( \vec { x } ) : : = \int _ { 0 } ^ { 1 } \frac { \partial F ( \tau ( \alpha ) ) } { \partial \tau _ { j } ( \alpha ) } \frac { \partial \tau _ { j } ( \alpha ) } { \partial \alpha } d \alpha ,
+$$
+
+118 where $c _ { j }$ represents $x _ { j }$ ’s contribution to the difference between baseline prediction $F ( \vec { b } )$ and $F ( \vec { x } )$ .   
+119 In this work, we leverage the integrated gradients technique to dynamically adjust the order of our   
+120 proposed sequential credit assignment according to each agent’s contribution to the team.
+
+# 3.2 Sequential MARL Framework
+
+122 The relationship in a multi-agent system is complicated, as every agent makes decisions based on   
+123 the environment interfered with by the other agents. If we model each agent as a node and model   
+124 the cooperations between them as edges, the cooperative relationship will be built as a complicated   
+125 web-like graph shown in Figure 1(a). Evaluating the actions of any agent should take into account   
+126 the behaviors of other agents in this situation. It is hard to judge whether an agent’s current action is   
+127 beneficial to the team when we have not evaluated other agents’ actions. If we cannot determine an   
+128 analysis order, we can only analyze all the agents implicitly as most existing methods did, and the   
+129 cooperation is often fitted only by deep neural networks, leading to unsatisfactory results.   
+130 This section presents a sequential framework for cooperative MARL, which aims to analyze agents’   
+131 actions one by one. Our key assumption is that evaluations of some agents in a team are less affected   
+132 than others. Thus we can study these less-affected agents first and then analyze the others based on   
+133 the actions of these already-studied agents. For instance, when evaluating a staff’s action, the CEO’s   
+134 decision plays a vital role because we have to judge whether the staff obeys the command or not. On   
+135 the contrary, the staff intuitively has little impact on evaluating the CEO’s decision. In assessing the   
+136 CEO, we often consider external factors such as market situation, modeled as state $s$ in MARL.   
+137 We introduce a variable $\mathcal { O } _ { i }$ to help model this sequential MARL framework. This additional variable   
+138 represents a random event that our cooperation study (e.g., credit assignment) on agent $a _ { i }$ is optimal or   
+139 precise. Then the probability $p ( \mathcal { O } _ { i } )$ denotes the accuracy of our research on agent $a _ { i }$ . For illustration   
+140 and understanding convenience, we discuss a simple multi-agent system with three agents as an   
+141 example, in which agents are identified by $a _ { i } ( i \in \mathsf { \bar { \{ 1 , 2 , 3 \} } } )$ . In original MARL, the evaluation of   
+142 agent $a _ { i }$ will influence all the other agents’ assessments. Thus events $\mathcal { O } _ { 1 }$ , $\mathcal { O } _ { 2 }$ and $\mathcal { O } _ { 3 }$ are mutually   
+143 dependent, as shown in Figure 1(b). We calculate the probability of studying the system accurately   
+144 by computing conditional probabilities:
+
+![](images/c855a712f9bbbfe89c2550cc1247e89d58da7b449b5632a9d8b3b4879f2e6264.jpg)  
+Figure 1: A toy example with three agents. (a) Agents affect each other as they choose actions based on the state interfered with by the others’ actions. (b) The study on one agent will influence all the other agents’ assessments in the original MARL framework. Agent’s cooperation analyses are interrelated. (c) Each agent’s cooperation study in the proposed sequential MARL framework. Dotted arrows representing correlations decrease from 6 in (b) to 3 in (c), reducing the complexity by half. This merit also holds for systems with other numbers of agents.
+
+$$
+\begin{array} { r l } { p ( \mathcal { O } _ { 1 } , \mathcal { O } _ { 2 } , \mathcal { O } _ { 3 } ) = p ( \mathcal { O } _ { 1 } ) \cdot p ( \mathcal { O } _ { 2 } | \mathcal { O } _ { 1 } ) \cdot p ( \mathcal { O } _ { 3 } | \mathcal { O } _ { 1 } , \mathcal { O } _ { 2 } ) } & { { } } \\ { \vdots } \\ { = p ( \mathcal { O } _ { 3 } ) \cdot p ( \mathcal { O } _ { 2 } | \mathcal { O } _ { 3 } ) \cdot p ( \mathcal { O } _ { 1 } | \mathcal { O } _ { 2 } , \mathcal { O } _ { 3 } ) } & { { } } \end{array}
+$$
+
+145 where $p ( \mathcal { O } _ { j } | \mathcal { O } _ { i } )$ denotes the probability of agent $a _ { j }$ ’s accurate analysis under the condition of   
+146 conducting a precise study on agent $a _ { i }$ . It also indicates the accuracy of $a _ { j }$ ’s analysis conditions on   
+147 precisely assess $a _ { i }$ . We then conclude that:
+
+148 where $i , j , k \in \{ 1 , 2 , 3 \} , i \neq j , k \neq i , j$
+
+$$
+\begin{array} { r l } & { \quad p ( \mathcal { O } _ { 1 } , \mathcal { O } _ { 2 } , \mathcal { O } _ { 3 } ) = p ( \mathcal { O } _ { i } ) \cdot p ( \mathcal { O } _ { j } | \mathcal { O } _ { i } ) \cdot p ( \mathcal { O } _ { k } | \mathcal { O } _ { i } , \mathcal { O } _ { j } ) } \\ & { , 3 \} , i \not = j , k \not = i , j . } \end{array}
+$$
+
+149 We take Equ.(2a) as an example. To study the cooperation of this multi-agent system precisely (i.e.,   
+150 big $p ( \mathcal { O } _ { 1 } , \mathcal { O } _ { 2 } , \mathcal { O } _ { 3 } ) )$ , we can first analyze $a _ { 1 }$ as accurately as possible (i.e., big $p ( \mathcal { O } _ { 1 } ) )$ and then go   
+151 on to investigate $a _ { 2 }$ and $a _ { 3 }$ respectively with the best possible accuracy (i.e., big $\partial ( \mathcal { O } _ { 2 } | \mathcal { O } _ { 1 } )$ and   
+152 $p ( \mathcal { O } _ { 3 } | \mathcal { O } _ { 1 } , \mathcal { O } _ { 2 } ) )$ under the condition of preceding agents’ precise analysis.   
+153 The sequential MARL framework reduces the complexity of the model with six dotted arrows that   
+154 indicate correlations between agents’ evaluations in Figure 1(b) by half, as those three dotted lines in   
+155 Figure 1(c) show. Equ.(3) suggests that we can analyze the cooperation of a multi-agent system in   
+156 any order, but from the CEO-Staff example, we can see that the difficulty of analyzing in various   
+157 orders is not the same. Further discussion on the sequence will show in Section 3.4.   
+158 In general, we specify an order to analyze the cooperation in the sequential MARL framework. We   
+159 fix an agent’s actions after assessing it and study a particular agent based on the fixed actions of its   
+160 preceding agents, reflecting the intuition that a CEO’s decision has a strong influence on evaluating   
+161 the staff in the example mentioned earlier. This sequential MARL framework significantly alleviates   
+162 the correlations in studying agents and helps us assess their cooperation more directly.
+
+# 3.3 Sequential Credit Assignment
+
+64 Following the CTDE paradigm, we utilize a centralized critic for each actor to follow a gradient   
+165 based on an advantage function $A$ estimated from this critic:
+
+$$
+g = \nabla _ { \theta ^ { \pi } } \log \pi \left( u | \tau _ { t } ^ { a } \right) A .
+$$
+
+![](images/1a7321a0ed108bed657b77946907348e4522b7b34d52af5ce5ec1f220e47d2ab.jpg)  
+Figure 2: Performances between COMA’s counterfactual advantage and ours in two environments. (Left) Predator-Prey. Three predators cooperate to chase a faster prey that acts randomly in an area containing two obstacles. The game terminates when a predator captures the prey, and then a shared reward is given. The predators trained by our advantage capture the prey faster. (Right) Cooperative Navigation initializes three agents and three landmarks with random locations. Agents cooperate to cover all the landmarks, and the shared reward is the negative sum of displacements between each landmark and its nearest agent. Our method helps the team gain bigger rewards than COMA.
+
+166 The advantage function $A$ for each actor explicitly deduces how that particular agent contributes to   
+167 the team. COMA [6] introduced a counterfactual baseline inspired by difference rewards [34]. For   
+168 each agent $a$ , COMA computes an advantage function that compares the Q-value for the action $u ^ { a }$ to   
+169 a counterfactual baseline that marginalizes out $u ^ { a }$ while keeping the others’ actions $\mathbf { u } ^ { - a }$ fixed:
+
+$$
+A _ { C O M A } ^ { a } ( s , { \mathbf { u } } ) = Q \left( s , \left( u ^ { a } , { \mathbf { u } } ^ { - a } \right) \right) - \sum _ { u ^ { \prime } \circ } \pi ^ { a } \left( u ^ { \prime } { } ^ { a } | \tau ^ { a } \right) \cdot Q \left( s , \left( { \mathbf { u } } ^ { - a } , u ^ { \prime } { } ^ { a } \right) \right) .
+$$
+
+170 COMA avoids expensive calculations through careful network design. However, each agent’s   
+171 contribution deduced by COMA is still imperfect. The evaluation of $u ^ { a }$ is based on the fixed $\mathbf { u } ^ { - a }$   
+172 in Equ.(5), so agent $a$ will learn a policy that works better with $\mathbf { u } ^ { - a }$ in this way. It ignores the joint   
+173 actions $( u ^ { a } , \mathbf { u } ^ { - a \prime } )$ with $\mathbf { u } ^ { - a \prime } \neq \mathbf { u } ^ { - a }$ that may lead to unexpected results when assessing $u ^ { a }$ .   
+174 To analyze each agent $a$ ’s contribution more objectively, we consider the influence of all joint actions   
+175 with $u ^ { a }$ . Considering all potential action combinations, we calculate a counterfactual advantage for   
+176 each agent’s action, derived by computing the expectation on all the actions of other agents:
+
+$$
+A ^ { a } ( s , { \mathbf { u } } ) = \mathbb { E } _ { { \mathbf { u } } ^ { - a } } \left[ Q \left( s , \left( u ^ { a } , { \mathbf { u } } ^ { - a } \right) \right) \right] - \mathbb { E } _ { { \mathbf { u } } ^ { - a } } \left[ \sum _ { u ^ { \prime } { } ^ { a } } \pi ^ { a } \left( u ^ { \prime a } | \tau ^ { a } \right) \cdot Q \left( s , \left( { \mathbf { u } } ^ { - a } , u ^ { \prime a } \right) \right) \right] .
+$$
+
+177 Under our proposed sequential MARL framework, we carry out credit assignment according to a   
+178 specific order, and there is no need to consider all the possible joint actions. After assessing agent $a$ ,   
+179 we fix its action and evaluate agents after it based on $a$ ’s fixed action, so the following agents’ credit   
+180 assignments do not have to compute the expectation on $u ^ { a }$ anymore.
+
+181 We now give the detailed sequential credit assignment for a team with $n$ agents identified by 182 $a _ { i } ( i \in \{ 1 , { \overline { { \ldots , n } } } \} )$ under one specific sequence $\{ a _ { 1 } , a _ { 2 } , . . . , a _ { n } \}$ , and it can also be concluded from the rest 183 $( n ! - 1 )$ orders in the same way. Here we denote $\mathbf u _ { a _ { 1 } } ^ { a _ { i - 1 } } \stackrel { \cdot } { = } \left[ u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } \right]$ $( i = 2 , 3 , . . . , n )$ .
+
+184 As for agent 185 i  been deduced. We fix the leading agents’ actions and assess agent $( i \neq 1 )$ ) in the sequence, the contribution of its leading agents $a _ { i }$ 1 2’s action based on $a _ { 1 } , a _ { 2 } , . . . , a _ { i - 1 }$ $\mathbf { u } _ { a _ { 1 } } ^ { a _ { i - 1 } }$ has , so   
+186 there is no need to calculate the expectations on $[ u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } ]$ , simplifying Equ.(6) to:
+
+$$
+\begin{array} { r l } & { \displaystyle \ = \sum _ { u ^ { \prime } { } ^ { a _ { i } + 1 } } \cdot \cdot \cdot \sum _ { u ^ { \prime } { } ^ { a _ { n } } } \pi ^ { a _ { i } + 1 } \left( u ^ { \prime } { } ^ { a _ { i } + 1 } \left. \tau ^ { a _ { i } + 1 } \right. \cdot \cdot \cdot \pi ^ { a _ { n } } \left( u ^ { \prime } { } ^ { a _ { n } } \left. \tau ^ { a _ { n } } \right. \cdot \right. \right. Q \left( s , \left( \mathbf { u } _ { a _ { 1 } } ^ { a _ { i } } , u ^ { \prime } { } ^ { a _ { i } + 1 } , \cdot \cdot \cdot , u ^ { \prime } { } ^ { a _ { n } } \right) \right) \right. } \\ & { \left. \left. \quad - \sum _ { u ^ { \prime } { } ^ { a _ { i } } } \cdot \cdot \cdot \sum _ { u ^ { \prime } { } ^ { a _ { n } } } \pi ^ { a _ { i } } \left( u ^ { \prime } { } ^ { a _ { i } } \left. \tau ^ { a _ { i } } \right. \cdot \cdot \cdot \pi ^ { a _ { n } } \left( u ^ { \prime } { } ^ { a _ { n } } \left. \tau ^ { a _ { n } } \right) \cdot Q \left( s , \left( \mathbf { u } _ { a _ { 1 } } ^ { a _ { i } - 1 } , u ^ { \prime } { } ^ { a _ { i } } , \cdot \cdot \cdot \cdot \right. , u ^ { \prime } { } ^ { a _ { n } } \right) \right) \right. \right. } \end{array}
+$$
+
+187 Then the first agent $a _ { 1 }$ ’s advantage is:
+
+$$
+\begin{array} { l } { { \displaystyle { \cal A } ^ { a _ { 1 } } \left( s , { \bf u } \right) = \sum _ { u ^ { \prime } = 2 } \cdots \sum _ { u ^ { \prime } = n } \pi ^ { a _ { 2 } } \left( u ^ { \prime } { } ^ { a _ { 2 } } \big \vert \tau ^ { a _ { 2 } } \right) \cdot \cdot \cdot \pi ^ { a _ { n } } \left( u ^ { \prime } { } ^ { a _ { n } } \big \vert \tau ^ { a _ { n } } \right) \cdot Q \left( s , \big ( u ^ { a _ { 1 } } , u ^ { \prime } { } ^ { a _ { 2 } } , \cdot \cdot \cdot , u ^ { \prime } { } ^ { a _ { n } } \big ) \right) } \ ~ } \\ { { \displaystyle ~ - \sum _ { u ^ { \prime } = 1 } \cdot \cdot \cdot \sum _ { u ^ { \prime } = n } \pi ^ { a _ { 1 } } \left( u ^ { \prime } { } ^ { a _ { 1 } } \big \vert \tau ^ { a _ { 1 } } \right) \cdot \cdot \cdot \pi ^ { a _ { n } } \left( u ^ { \prime } { } ^ { a _ { n } } \big \vert \tau ^ { a _ { n } } \right) \cdot Q \left( s , \big ( u ^ { \prime } { } ^ { a _ { 1 } } , u ^ { \prime } { } ^ { a _ { 2 } } , \cdot \cdot \cdot , u ^ { \prime } { } ^ { a _ { n } } \big ) \right) } \ ~ } \end{array}
+$$
+
+![](images/c668245e9dcfbddf169779735f299af2d0adc516e3253450dc16771d4ff9007d.jpg)  
+Figure 3: (a) A centralized mixing critic network that maps the state into a set of weights (top) and the decentralized agent network structure (bottom). (b) The overall SeCA architecture. (c) Critic learning (top) and policy learning (bottom) flow. View in color if possible for better understanding.
+
+188 To illustrate the effectiveness of our sequential counterfactual advantage, we conduct a simple   
+189 but illuminating test in two common multi-agent particle environments [11], Predator-Prey and   
+190 Cooperative Navigation. We train both methods with 5 random seeds, and agents are trained for 5000   
+191 episodes. We provide detailed information on the environments and experiments in the Appendix. As   
+192 shown in Figure 2, our sequential advantage functions help agents handle the task faster and better.   
+93 Our sequential advantage for each agent achieves an additive decomposition of the total advantage   
+94 function, which to some extent explains the soundness and superiority of our advantage over COMA’s.
+
+95 Claim 1. The proposed sequential credit assignment achieves additive advantage-decomposition.
+
+196 Proof. See Appendix A.
+
+97 Facing the same problem as COMA that those evaluations are expensive, we model the first term   
+98 in Equ.(7) as a function $f _ { \phi }$ of $\left( u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i } } , \pi ^ { a _ { i + 1 } } , . . . , \pi ^ { a _ { n } } \right)$ to address this issue, and the second   
+199 term is a similar function of $\bigl ( u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } , \pi ^ { a _ { i } } , . . . , \pi ^ { a _ { n } } \bigr ) .$ Thus, we rewrite Equ.(7) as:
+
+$$
+A ^ { a _ { i } } = f _ { \phi } \left( s ; u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i } } , \pi ^ { a _ { i + 1 } } , . . . , \pi ^ { a _ { n } } \right) - f _ { \phi } \left( s ; u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } , \pi ^ { a _ { i } } , . . . , \pi ^ { a _ { n } } \right) .
+$$
+
+Here 200 $f _ { \phi }$ is a function evaluating agents’ action-policy vectors, where $f _ { \phi } \left( u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { n } } \right) = Q$ and 201 $f _ { \phi } \left( \pi ^ { a _ { 1 } } , \pi ^ { a _ { 2 } } , . . . , \pi ^ { a _ { n } } \right) = V$ . We design the complete setup for SeCA, which is illustrated in Figure 3.
+
+202 Critic Learning. We train critic $f _ { \phi }$ on-policy to estimate $Q$ , utilizing a practical variant of $\mathrm { T D } ( \lambda )$ [27]   
+203 adapted for use with deep neural networks. In particular, the critic parameter $\phi$ is updated by minibatch   
+204 gradient descent to minimize the following loss:
+
+$$
+\mathcal { L } _ { t } ( \phi ) = \left( y _ { t } ^ { ( \lambda ) } - f _ { \phi } ( s _ { t } , \mathbf { u } _ { t } ) \right) ^ { 2 } , \mathrm { ~ w h e r e ~ } y _ { t } ^ { ( \lambda ) } = r _ { t } + \gamma \left( \lambda y _ { t + 1 } ^ { ( \lambda ) } + ( 1 - \lambda ) f _ { \phi ^ { - } } ( s _ { t + 1 } , \mathbf { u } _ { t + 1 } ) \right) .
+$$
+
+205 We utilize a target critic $f _ { \phi ^ { - } }$ [14] to improve learning stability and update ${ \phi } ^ { - }  \phi$ periodically. The   
+206 critic learning flow is shown at the top of Figure 3(c). The input for critic training is the state $s$ and   
+207 the action vector $\mathbf { u } = \left[ u ^ { 1 } , u ^ { 2 } , . . . , u ^ { n } \right]$ denoted as $\mathbf { v } ^ { 1 : n }$ .   
+208 Policy Learning. We optimize each agent $a$ ’s policy parameter $\theta _ { a }$ by maximizing the following   
+209 objective, which contains our proposed advantage function and an entropy regularization term $\mathcal { H }$ :
+
+$$
+g ^ { a } = \mathbb { E } _ { \tau \sim \pi } \left[ \nabla _ { \theta _ { a } } \log \pi ^ { a } ( u ^ { a } | \tau ^ { a } ) A ^ { a } ( s , \mathbf { u } ) + \mathcal { H } \left( \pi ^ { a } ( \cdot | \tau ^ { a } ) \right) \right] ,
+$$
+
+where the derivative of the adaptive entropy regularization term 210 $\mathcal { H } ( \pi ^ { a } ( \cdot | \tau ^ { a } ) )$ [39] with respect to the 211 $i$ -th action probability $p _ { i } ^ { a }$ is given by:
+
+$$
+\begin{array} { r } { d \mathcal { H } _ { i } : = - \xi \cdot ( \log p _ { i } ^ { a } + 1 ) / H ( \pi ^ { a } ( \cdot | \tau ^ { a } ) ) , \mathrm { ~ w h e r e ~ } H ( \pi ^ { a } ( \cdot | \tau ^ { a } ) ) = \mathbb { E } _ { u ^ { a } \sim \pi ^ { a } } \left[ - \log \pi ^ { a } ( u ^ { a } | \tau ^ { a } ) \right] . } \end{array}
+$$
+
+212 We share parameters among agents, and the gradient we use to train the actor shared by all agents is:
+
+$$
+g = \mathbb { E } _ { \tau \sim \pi } \left[ \sum _ { a } \left( \nabla _ { \theta _ { a } } \log \pi ^ { a } ( u ^ { a } | \tau ^ { a } ) A ^ { a } ( s , \mathbf { u } ) + \mathcal { H } \left( \pi ^ { a } ( \cdot | \tau ^ { a } ) \right) \right) \right] .
+$$
+
+213 The inputs of the centralized critic $f _ { \phi }$ to compute the advantage function are the state $s$ and two   
+214 action-policy vectors $\mathbf { v } ^ { 1 : i } = \left[ u ^ { 1 } , . . . , \dot { u } ^ { i } , \pi ^ { i + 1 } , . . . , \pi ^ { n } \right]$ and $\mathbf { v } ^ { 1 : i - \bar { 1 } } = \left[ u ^ { 1 } , . . . , u ^ { i - 1 } , \pi ^ { i } , . . . , \pi ^ { n } \right]$ . The   
+215 bottom of Figure 3(c) demonstrates the policy learning flow.
+
+# 3.4 Sequence Adjustment Through Integrated Gradients
+
+We apply integrated gradients to adjust the credit assignment sequence dynamically. Reviewing the enlightening and straightforward CEO-Staff example discussed in Section 3.2, we can evaluate the staff’s behavior based on the CEO’s decision, but assessing the CEO does not require much attention to the staff’s action. Therefore, we would analyze the CEO first and then evaluate the staff based on the CEO’s current action. However, this example is not generalized for two reasons: (1) There are often multiple agents taking the same role in a system with superior-subordinate relationships, and the sequence of these agents is hard to determine; (2) Not all scenarios have such superior-subordinate relationships. The agents often do not need to follow others’ commands in many applications.
+
+225 We generalize the CEO-Staff example to propose a universal model. Instead of focusing on the roles   
+226 among the agents as in [31, 32], we are more interested in agents’ contributions. Although the CEO   
+227 and the staff have a superior-subordinate relationship, they are essentially employees of an enterprise.   
+228 The staff plays an auxiliary role and acts based on the CEO’s decision. The staff’s work is meaningful   
+229 only if the CEO’s decision is correct. Therefore, we often intuitively assume that an enterprise’s   
+230 leader is paid more and contributes more. Based on this, we transform the roles of the CEO and staff   
+231 into employees with different contributions to the enterprise. In the sequential MARL framework, we   
+232 first assign credit to the agent with a higher contribution to the team.   
+233 The attribution method is a powerful way to determine the influence of input features’ each component   
+234 on the network output value [2]. Among them, integrated gradients [25] leverages path integral to   
+235 aggregate gradients along the inputs that fall on the lines between the baseline and the input, which   
+236 is a natural tool for measuring each agent’s contribution. QPD [35] utilizes the integrated gradient   
+237 attribution technique to decompose shared rewards along trajectory paths, revealing how much each   
+238 agent’s observation and action contributes to the global Q value. However, it remains unclear whether   
+239 individual Q value should be linearly correlated to or approximated by the agent’s contribution, as in   
+240 the case of QPD. The proper connection between agents’ contributions and their individual Q values   
+241 in a cooperative team is worth well studied for the community.
+
+Here we avoid detailed analysis on the relationship between agents’ contributions and their individual rewards. Instead, we use integrated gradients to measure agents’ contributions to the state transition and adjust the credit assignment sequence based on their contributions. In particular, we estimate agent $a$ ’s contribution $c ^ { a }$ in the trajectory path $\tau _ { t _ { 1 } } ^ { t _ { 2 } }$ from time $t _ { 1 }$ to $t _ { 2 }$ based on its policy vector $\pi ^ { a }$ :
+
+$$
+c ^ { a } = \sum _ { x _ { j } \in \pi ^ { a } } \mathrm { P a t h I G } _ { j } ^ { \tau _ { t _ { 1 } } ^ { t _ { 2 } } } ( \pi ^ { a } ) ,
+$$
+
+246 where $x _ { j }$ is $j$ -th dimension of the policy vector $\pi ^ { a }$ . The computation for PathIG is shown in Equ.(1).   
+247 We compute each agent’s contribution $c$ to the state transition from $s _ { t _ { 1 } }$ to $s _ { t _ { 2 } }$ and analyze the agent   
+248 with higher $c$ first. We further study the adjustment frequency and its effectiveness in Section 4.2
+
+# 4 Experiments and Analysis
+
+# 4.1 Experimental Setup
+
+We consider a challenging set of cooperative StarCraft II maps from the SMAC benchmark [23] classified as Easy, Hard, and Super Hard scenarios according to the baseline algorithms’ performance. The inherent differences among various methods and their training procedure (e.g., on/off-policy learning for value-based/policy-based methods) bring difficulties when comparing methods in a reasonably fair manner without introducing additional components (e.g., importance sampling [13, 33] for off-policy methods). To attribute any poor performance of policy-based methods to potential algorithmic limitations or poor training conditions (in particular, high variance due to small batch sizes or insufficient gradient steps), we follow [5, 39], training all methods with 32 parallel runners to generate trajectories and using batches of 32 episodes. We evaluate each method every 320K steps with 32 episodes and report the 1st, median, and 3rd quartile win rates across 5 random seeds. Detailed information about the scenarios and the experimental setup is shown in the Appendix.
+
+![](images/1136df9f6bcfaf9c4dc17813aee3a729a186de53396fdc91896a637a666edaf4.jpg)  
+Figure 4: Ablations for SeCA’s key elements on scenario MMM2 (Super Hard). (a) investigates the effects of our sequential advantage and network architecture. (b) validates our sequence adjustment through integrated gradients. (c) shows the test win percentage with various adjustment frequencies.
+
+# 4.2 Ablation Studies
+
+# We first carry out ablation experiments on a Super Hard map MMM2 to validate key elements of SeCA.
+
+Proposed Advantage and Architecture. In Section 3.3, we compare our sequential advantage with COMA’s in two simple multi-agent particle environments and show our superiority in Figure 2. Afterward, we introduce a $f _ { \phi }$ approximation and a corresponding network architecture. Here we apply the same approximation and architecture for COMA’s counterfactual advantage (COMA-newArchi) and compare it with the original COMA and our method SeCA to show the effects of our advantage function, approximation, and network architecture. The result is illustrated in Figure 4(a). COMA performs poorly on this Super Hard map but acquires significant improvement with our approximation and architecture. Our sequential advantage further accelerates and stabilizes the training.
+
+Sequence Adjustment Algorithm. SeCA’s credit assignment sequence is dynamic. We compare our method with some intuitive adjustments to validate its effects. One could first evaluate agents with higher current-action probability (SeCA-Prob) or lower policy entropy (SeCA-Entro), as these agents are more confident in their acts, and we can assess other agents based on their behaviors. Since SeCA-Prob and Entro get a new order at each step, to be fair, we set the path length in Equ.(14) to one, i.e., consider agents’ contributions based on the transition from $s _ { t }$ to $s _ { t + 1 }$ (SeCA-IG-1). Figure 4(b) illustrates that SeCA-Prob and Entro learn better than the fixed method (SeCA-Fixed), but Prob has a larger variance than Entro. Fixed is better than expected, which we believe is because that the fixed sequence acquires adequate training. Our integrated-gradients-adjustment performs the best in win rates and stability, and the others have inferior performance and incredibly high variance.
+
+Sequence Adjustment Frequency. We next consider how the sequence adjustment frequency in SeCA-IG affects the performance. Except per step adjustment (i.e., SeCA-IG-1), one could also update the sequence after a stage or an episode. If we change the credit assignment order for every episode during training (SeCA-IG-episode), then $\tau _ { t _ { 1 } } ^ { t _ { 2 } }$ in Equ.(14) represents a whole episode. As for stage adjustment, it is hard to define a stage in these tasks, and the stage length varies in diverse maps. Here we set stage length to 10 and 20, respectively denoted as SeCA-IG-10 and SeCA-IG-20. As the results in Figure 4(c) show, IG-1 and IG-episode have similar final win rates. However, IG-episode converges more quickly with smaller variance. The reason for IG-10(20)’s mediocre performance and high variance may be because the stage length needs to be dynamically adjusted. Inappropriate adjustment frequency fails to adapt to the stage changes in the task and causes insufficient training for each sequence. We utilized SeCA-IG-episode in other experiments and will investigate dynamic stage learning in the future to improve stage adjustment.
+
+# 94 4.3 Comparisons with State-of-the-arts
+
+We compare SeCA with some competitive algorithms, including the representative explicit credit assignment method COMA, the policy-based implicit method LICA, the common-used baseline QMIX and QTRAN. Methods are evaluated on 6 scenarios, including 2 Easy ones (2s3z, 1c3s5z), 2 Hard ones $( 2 \mathsf { c } _ { - } \mathsf { v s } _ { - } 6 4 \mathsf { z g } , 3 \mathsf { s } _ { - } \mathsf { v s } _ { - } 5 \mathsf { z } )$ , and 2 Super Hard ones (MMM2, $ { 3 \mathbf { s } } 5  { \mathbf { z } } _ { - }  { \mathbf { v } }  { \mathbf { s } } _ { - } 3  { \mathbf { s } } 6 z ,$ . We train all methods for 32 million steps in Easy maps and 64 million steps in Hard and Super Hard maps. These scenarios involve homogeneous and heterogeneous teams, symmetric and asymmetric battles, allowing a holistic study on all methods. Our experiments are based on the latest PyMARL [23]
+
+![](images/38587f1c30280214c4c2e9ac29dc02023f61d16f0bacb03b84a7241ac6bc2863.jpg)  
+Figure 5: The comparison of SeCA against various baseline algorithms on six SMAC maps.
+
+302 utilizing SC2.4.10. Performance is not always comparable between versions, so the results may be   
+303 subtly different from the original papers.   
+304 As we can see in Figure 5, SeCA demonstrates its robustness by achieving good performances in   
+305 scenarios with various characteristics. All methods except COMA and QTRAN solve two Easy   
+306 scenarios, and SeCA performs better in convergence speed and stability. SeCA’s advantage is further   
+307 extended in the Hard map $\mathsf { 2 c _ { - } v s _ { - } 6 4 z g }$ , and it converges significantly faster than other methods.   
+308 Although classified only as Hard, $ { 3 \mathrm { s } } _ { - }  { \mathrm { v } }  { \mathrm { s } } _ { - }  { 5 z }$ invalidates most algorithms except QMIX and SeCA, as   
+309 Stalkers have to learn dispersing and making enemies give chase while maintaining enough distance   
+310 ("kiting" technique) in this map. SeCA has a higher variance than QMIX. This is possibly because   
+311 the Stalkers’ scattering prioritizes individual performance over cooperation which is more in line   
+312 with QMIX’s monotonicity constraint. Nevertheless, SeCA’s performance improvements on the   
+313 Super Hard scenarios MMM2 and $ { 3 \mathbf { s } } 5  { \mathbf { z } } _ { - }  { \mathbf { v } }  { \mathbf { s } } _ { - } 3  { \mathbf { s } } 6  { \mathbf { z } }$ demonstrate the effectiveness of our method. LICA’s   
+314 performance in $ { 3 \mathbf { s } } 5  { \mathbf { z } } _ { - }  { \mathbf { v } }  { \mathbf { s } } _ { - } 3  { \mathbf { s } } 6  { \mathbf { z } }$ here is different from the original paper, as the original results for   
+315 this map are obtained by using a different entropy coefficient, which is explained in its open-source   
+316 implementation.1 This parameter tuning is unfair when comparing methods, so all experiments in this   
+317 paper use the fixed entropy coefficient. We also visualize the learned sequences in different battles of   
+318 $3 { \bf s } _ { - } \mathtt { v } { \bf s } _ { - } 5 z$ to provide insights into our sequence adjustment in the Appendix.   
+19 We are supposed to compare our method with QPD that also utilizes integrated gradients to show   
+320 our improvement. However, QPD modifies the original SMAC environment to acquire additional   
+321 information for policy training, which is mentioned in its open-source implementation.2 Therefore, it   
+322 is unfair to compare QPD’s learning curves in the modified environment with other methods, and   
+323 QPD’s authors did not provide methods’ learning curves comparison in the original paper. We follow   
+324 them, providing a win rate table in the Appendix to show our superiority over QPD.
+
+# 5 Conclusions and Future Work
+
+This paper presents SeCA, a cooperative MARL framework with sequential credit assignment. SeCA computes counterfactual advantage functions to evaluate each agent based on the actions of the preceding agents under a specific sequence. The sequence is adjusted dynamically according to agents’ contributions to the team deduced by integrated gradients. SeCA accelerates policy convergence and improves the final performance over existing recognized methods in practice. In the future, we will further investigate stage learning in an episode and adjust the sequence per stage to improve SeCA and achieve adaptive cooperation in various task situations.
+
+References   
+[1] Marco Ancona, Enea Ceolini, Cengiz Öztireli, and Markus Gross. Towards better understanding of gradient-based attribution methods for deep neural networks. In International Conference on Learning Representations, 2018.   
+[2] Guillem Brasó Andilla. Attribution methods for deep convolutional networks.   
+[3] Yongcan Cao, Wenwu Yu, Wei Ren, and Guanrong Chen. An overview of recent progress in the study of distributed multi-agent coordination. IEEE Transactions on Industrial informatics, 9(1):427–438, 2012.   
+[4] Yu-han Chang, Tracey Ho, and Leslie Kaelbling. All learning is local: Multi-agent learning in global reward games. In Advances in Neural Information Processing Systems, pages 808–814, 2004.   
+[5] Yali Du, Lei Han, Meng Fang, Ji Liu, Tianhong Dai, and Dacheng Tao. Liir: Learning individual intrinsic reward in multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pages 4403–4414, 2019.   
+[6] Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In AAAI Conference on Artificial Intelligence, pages 2974–2982, 2018.   
+[7] Jayesh K Gupta, Maxim Egorov, and Mykel Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In International Conference on Autonomous Agents and Multiagent Systems, pages 66–83, 2017.   
+[8] Pablo Hernandez-Leal, Bilal Kartal, and Matthew E Taylor. A survey and critique of multiagent deep reinforcement learning. Autonomous Agents and Multi-Agent Systems, 33(6):750–797, 2019.   
+[9] Maximilian Hüttenrauch, Adrian Šošic, and Gerhard Neumann. Guided deep reinforcement ´ learning for swarm systems. In AAMAS Autonomous Robots and Multirobot Systems (ARMS) Workshop, 2017.   
+[10] Landon Kraemer and Bikramjit Banerjee. Multi-agent reinforcement learning as a rehearsal for decentralized planning. Neurocomputing, 190:82–94, 2016.   
+[11] Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pages 6382–6393, 2017.   
+[12] Anuj Mahajan, Tabish Rashid, Mikayel Samvelyan, and Shimon Whiteson. Maven: Multiagent variational exploration. In Advances in Neural Information Processing Systems, pages 7611–7622, 2019.   
+[13] A Rupam Mahmood, Hado van Hasselt, and Richard S Sutton. Weighted importance sampling for off-policy learning with linear function approximation. In Advances in Neural Information Processing Systems, pages 3014–3022, 2014.   
+[14] 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–533, 2015.   
+[15] Grégoire Montavon, Wojciech Samek, and Klaus-Robert Müller. Methods for interpreting and understanding deep neural networks. Digital Signal Processing, 73:1–15, 2018.   
+[16] Frans A Oliehoek and Christopher Amato. A concise introduction to decentralized POMDPs. Springer, 2016.   
+[17] Frans A Oliehoek, Matthijs TJ Spaan, and Nikos Vlassis. Optimal and approximate q-value functions for decentralized pomdps. Journal of Artificial Intelligence Research, 32:289–353, 2008.   
+380 [18] Afshin OroojlooyJadid and Davood Hajinezhad. A review of cooperative multi-agent deep reinforcement learning. arXiv preprint arXiv:1908.03963, 2019.   
+382 [19] Gregory Palmer, Karl Tuyls, Daan Bloembergen, and Rahul Savani. Lenient multi-agent deep reinforcement learning. In International Conference on Autonomous Agents and MultiAgent Systems, pages 443–451, 2018. [20] Scott Proper and Kagan Tumer. Modeling difference rewards for multiagent learning. In International Conference on Autonomous Agents and Multi-Agent Systems, pages 1397–1398, 2012.   
+388 [21] Tabish Rashid, Gregory Farquhar, Bei Peng, and Shimon Whiteson. Weighted qmix: Expanding monotonic value function factorisation. In Advances in Neural Information Processing Systems, pages 10199–10210, 2020. [22] Tabish Rashid, Mikayel Samvelyan, Christian Schroeder, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: Monotonic value function factorisation for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pages 4295–4304, 2018. [23] Mikayel Samvelyan, Tabish Rashid, Christian Schroeder de Witt, Gregory Farquhar, Nantas Nardelli, Tim G. J. Rudner, Chia-Man Hung, Philiph H. S. Torr, Jakob Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. CoRR, abs/1902.04043, 2019.   
+398 [24] Kyunghwan Son, Daewoo Kim, Wan Ju Kang, David Earl Hostallero, and Yung Yi. Qtran: Learning to factorize with transformation for cooperative multi-agent reinforcement learning. In International Conference on Machine Learning, pages 5887–5896, 2019. [25] Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In International Conference on Machine Learning, pages 3319–3328, 2017. [26] Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Valuedecomposition networks for cooperative multi-agent learning based on team reward. In International Conference on Autonomous Agents and MultiAgent Systems, pages 2085–2087, 2018. [27] Richard S Sutton. Learning to predict by the methods of temporal differences. Machine learning, 3(1):9–44, 1988.   
+410 [28] Kagan Tumer and Adrian Agogino. Distributed agent-based air traffic flow management. In International Joint Conference on Autonomous Agents and Multiagent Systems, pages 1–8, 2007. [29] Jianhao Wang, Zhizhou Ren, Terry Liu, Yang Yu, and Chongjie Zhang. Qplex: Duplex dueling multi-agent q-learning. arXiv preprint arXiv:2008.01062, 2020. [30] Jianhong Wang, Yuan Zhang, Tae-Kyun Kim, and Yunjie Gu. Shapley q-value: A local reward approach to solve global reward games. In AAAI Conference on Artificial Intelligence, pages 7285–7292, 2020. [31] Tonghan Wang, Heng Dong, Victor Lesser, and Chongjie Zhang. Roma: Multi-agent reinforcement learning with emergent roles. In International Conference on Machine Learning, pages 9876–9886, 2020. [32] Tonghan Wang, Tarun Gupta, Anuj Mahajan, Bei Peng, Shimon Whiteson, and Chongjie Zhang. Rode: Learning roles to decompose multi-agent tasks. arXiv preprint arXiv:2010.01523, 2020. [33] Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. arXiv preprint arXiv:1611.01224, 2016. [34] David H Wolpert and Kagan Tumer. Optimal payoff functions for members of collectives. In Modeling complexity in economic and social systems, pages 355–369. World Scientific, 2002.   
+[35] Yaodong Yang, Jianye Hao, Guangyong Chen, Hongyao Tang, Yingfeng Chen, Yujing Hu, Changjie Fan, and Zhongyu Wei. Q-value path decomposition for deep multiagent reinforcement learning. In International Conference on Machine Learning, pages 10706–10715, 2020.   
+[36] Dayong Ye, Minjie Zhang, and Yun Yang. A multi-agent framework for packet routing in wireless sensor networks. Sensors, 15(5):10026–10047, 2015.   
+[37] Wang Ying and Sang Dayong. Multi-agent framework for third party logistics in e-commerce. Expert Systems with Applications, 29(2):431–436, 2005.   
+[38] Kaiqing Zhang, Zhuoran Yang, and Tamer Ba¸sar. Multi-agent reinforcement learning: A selective overview of theories and algorithms. arXiv preprint arXiv:1911.10635, 2019.   
+[39] Meng Zhou, Ziyu Liu, Pengwei Sui, Yixuan Li, and Yuk Ying Chung. Learning implicit credit assignment for cooperative multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, 2020.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] We discussed it in the experiment analysis in Section 4.3 and future work in Section 5.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] We provided the proof of our Claim in the supplemental material.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We provided our code and instructions in the supplemental material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We described the training details in the supplemental material.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Figure 2, 4 and 5.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We described it in the supplemental material.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [Yes]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provided our code in the supplemental material.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]
+
+476 (b) Did you describe any potential participant risks, with links to Institutional Review   
+477 Board (IRB) approvals, if applicable? [N/A]   
+478 (c) Did you include the estimated hourly wage paid to participants and the total amount   
+479 spent on participant compensation? [N/A]

parse/train/IQgbmaoDDjd/IQgbmaoDDjd_content_list.json

@@ -0,0 +1,1254 @@
+[
+    {
+        "type": "text",
+        "text": "Cooperative Multi-Agent Reinforcement Learning with Sequential Credit Assignment ",
+        "text_level": 1,
+        "bbox": [
+            196,
+            122,
+            805,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Centralized training with decentralized execution is a standard paradigm for coop  \n2 erative multi-agent reinforcement learning (MARL), with credit assignment being   \n3 a major challenge. In this paper, we propose a cooperative MARL method with   \n4 sequential credit assignment (SeCA) that deduces each agent’s contribution to the   \n5 team’s success one by one to learn better cooperation. We first present a sequential   \n6 MARL framework, under which we introduce a new counterfactual advantage to   \n7 evaluate each agent based on its preceding agents’ actions in a specific sequence.   \n8 As this credit assignment sequence tremendously impacts the performance, we   \n9 further present a sequence adjustment algorithm utilizing integrated gradients. It   \n10 dynamically modifies the sequence among agents according to their contribution   \n11 to the team. SeCA employs a network which either estimates the Q value for   \n12 training the centralized critic or deduces the proposed advantage of each agent for   \n13 decentralized policy learning. Our method is evaluated on a challenging set of   \n14 StarCraft II micromanagement tasks and achieves state-of-the-art performance. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            566,
+            310,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 Cooperative multi-agent reinforcement learning (MARL) is a helpful tool in numerous applications   \n17 such as robot swarm control [9], autonomous vehicle coordination [3], network routing [36], and   \n18 productivity optimization [37]. This kind of problem where agents learn coordinated policies to   \n19 optimize the global reward has been extensively studied in recent years [7, 19, 18, 38, 8].   \n20 One natural way of addressing the cooperative MARL problem is the centralized approach, which   \n21 treats the team as a single actor with a joint action space. Although we can trivially apply single-agent   \n22 reinforcement learning algorithms to such settings, it usually does not scale well because the size of   \n23 the joint action space grows exponentially with the number of agents. Besides, it is not applicable   \n24 in real-world settings due to the inherent constraints on agent observability and communication.   \n25 An alternative approach is to learn decentralized policies by independently training agents based   \n26 on their local observations, but simultaneous exploration often brings non-stationarity that causes   \n27 unstable learning and difficulties in convergence. As a result, the majority of work on MARL   \n28 follows the centralized training with decentralized execution (CTDE) paradigm [17, 10, 22, 6], where   \n29 decentralized policies can access extra state information during training.   \n30 A crucial challenge of the CTDE paradigm in cooperative settings is to correctly deduce each agent’s   \n31 contribution to the team’s success, also known as the multi-agent credit assignment problem [4].   \n32 Existing methods can be classified as implicit and explicit credit assignment [39]. Previous implicit   \n33 methods often deduce all agents’ contributions by representing the global state-action value as an   \n34 aggregation of each agent’s state-action value [26, 22, 12, 24, 21, 29] and assigning the shared rewards   \n35 to each agent according to the joint action at one time. In this way, these methods avoid the complex   \n36 interaction analysis and instead fit these cooperation relationships by neural networks. However,   \n37 implicit methods often face limitations in expressiveness, and their extensions to continuous action   \n38 spaces may require additional strategies [39].   \n39 On the other hand, recognized explicit approaches calculate difference rewards [34] against a certain   \n40 reward baseline [28, 20, 6]. However, in cooperative MARL, evaluating any agent’s action requires   \n41 considering the actions of all agents, so it is often difficult to determine the impact a particular agent’s   \n42 behavior has on the team when we have not assessed other agents’ actions. In other words, we can   \n43 not say that a single agent’s action is bad if the team receives a small reward because the shared   \n44 reward is not decided only by this agent’s behavior. Maybe its action is actually good in that state.   \n45 This paper presents a sequential credit assignment SeCA to evaluate individual agent actions explicitly   \n46 and sequentially. Our motivation is to address the drawbacks of implicit methods that neglect the   \n47 cooperation between agents or simply leave it to neural networks and further improve explicit credit   \n48 assignment. In summary, we face two main challenges to learn a better explicit credit assignment: (1)   \n49 how to alleviate the problem that it is hard to accurately deduce the contribution of one agent without   \n50 previously assessing all the others’ action, and (2) how to evaluate agents better in an explicit way.   \n51 To deal with (1), we introduce a sequential MARL framework. As mentioned above, without assessing   \n52 the behaviors of other agents, we would never be able to evaluate a given agent’s action accurately.   \n53 However, we point out in this paper that some agents are less affected by such influences than others,   \n54 and we can first assign credit to them. For instance, evaluating a staff’s action needs to take the   \n55 CEO’s command or action into consideration, while the former has little importance in assessing the   \n56 CEO. Thus, we could evaluate the CEO first without considering the staff’s behavior and then analyze   \n57 the staff based on the CEO’s action. We fully consider the action coordination between agents and   \n58 explicitly deduce contribution to them one by one according to a particular order, so as to make up   \n59 for the disadvantage of implicit methods that the cooperation is only inexplicably fitted by neural   \n60 networks. Intuitively, the order significantly impacts the overall performance, so we further propose   \n61 an algorithm to adjust the sequence dynamically through integrated gradients [25].   \n62 As for (2), we compute an advantage function for each agent to attribute agent contributions explicitly.   \n63 COMA [6] is a representative method that computes a baseline for each agent to reason about   \n64 counterfactuals in which only one agent $a$ ’s action changes, so its evaluation of $a$ ’s action is based on   \n65 the joint action $\\mathbf { u } ^ { - a }$ of other agents. In other words, the policy gradient of COMA only encourages   \n66 agent $a$ to learn in the direction that benefits the team while other agents are acting $\\mathbf { u } ^ { - a }$ , but the   \n67 others’ actions are not necessarily $\\mathbf { u } ^ { - a }$ when executing. Unlike COMA, we focus more on the action   \n68 coordination among agents and propose a new advantage under the proposed sequential framework.   \n69 We summarize the contributions of this paper as follows: (1) We propose a sequential MARL   \n70 framework in Section 3.2; (2) Under this framework, we introduce a sequential advantage function   \n71 for each agent to guide their learning explicitly in Section 3.3. We further prove that the sequential   \n72 credit assignment we proposed achieves additive advantage-decomposition. (3) We present a sequence   \n73 adjustment algorithm based on integrated gradients to modify the credit assignment order dynamically   \n74 in Section 3.4. This algorithm alleviates the impact caused by the sequence’s randomness and helps   \n75 achieve competitive performance on a challenging set of StarCraft II micromanagement tasks [23]. ",
+        "bbox": [
+            147,
+            598,
+            825,
+            654
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            660,
+            825,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            804,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            126,
+            825,
+            209
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            305,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            463,
+            825,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            566,
+            825,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "76 2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            689,
+            321,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "77 Explicit credit assignment gives valuable insights into agent actions’ contributions to the shared   \n78 team reward and substantially promotes policy optimization. The representative method COMA [6]   \n79 utilizes a counterfactual baseline that marginalizes out a single agent’s action while keeping the other   \n80 agents’ actions fixed to calculate the advantage function. However, the advantage evaluates a single   \n81 agent’s action based on the other agents’ current behaviors and ignores different action combinations.   \n82 SQDDPG [30] distributes the global reward reflecting each agent’s contribution through Shapley   \n83 Value. Although SQDDPG provides a theoretically justified framework, its assumption on the   \n84 observability and convex game makes it impractical and performs poorly in complex environments.   \n85 Implicit methods are a more common way when addressing the credit assignment challenge. Among   \n86 them, LICA [39] is a policy-based method, which learns an end-to-end differentiable optimization   \n87 where it trains a hypernetwork that maps the state into a set of weights which, in turn, maps the   \n88 action policies into the Q estimate. On the other hand, value-based methods often represent the   \n89 global state-action value as an aggregation of the individual values. The value decomposition is linear   \n90 in the earlier work VDN [26], and it ignores the state information. QMIX [22] learns a non-linear   \n91 mixing network with the global state and maps the individual state-action values into the joint Q value   \n92 estimate. Although QMIX performs well in various environments, it still faces the mixing network’s   \n93 monotonicity constraint limitation. QTRAN [24] further avoids the representation limitations by   \n94 using linear constraints between individual utilities and the global state-action value. It guarantees   \n95 optimal decentralization, but its constraints are computationally intractable, and the relaxations often   \n96 lead to unsatisfied performance. QPLEX [29] decomposes Q values following the dueling structure,   \n97 transferring the monotonicity condition from Q values to advantage values. QPD [35] leverages the   \n98 integrated gradient attribution technique to decompose global Q values along trajectory paths based   \n99 on the assumption that an agent’s local reward is linearly correlated with its contribution to the team. ",
+        "bbox": [
+            147,
+            724,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methods ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            252,
+            277,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            285,
+            307,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notations. This work considers a fully cooperative multi-agent task with $n$ agents $\\mathcal { A } = \\{ 1 , . . . , n \\}$ as a Dec-POMDP [16] defined by a tuple $\\mathbf { \\bar {  { G } } } = ( S , U , P , \\bar { r } , Z , O , n , \\gamma )$ . The environment has a true state $s \\in S$ . Each agent $a$ chooses an action $u _ { t } ^ { a }$ from its action space $U$ at each timestep $t$ and forms a joint action $\\mathbf { u } _ { t }$ that induces a transition in the environment according to the state transition function $P ( s _ { t + 1 } | s _ { t } , \\mathbf { u } _ { t } ) : S \\times U ^ { n } \\times S  [ 0 , 1 ] .$ . The agents share the same reward function $r ( s , \\mathbf { u } ) : S \\times u ^ { n }  \\mathbb { R }$ , and $\\gamma \\in [ 0 , 1 )$ is the discount factor. We consider partially observable scenarios in which agent $a$ acquires its local observation $z ^ { a } \\in Z$ drawn from $O ( s _ { t } , a ) : S \\times \\mathcal { A } \\to Z$ Each agent has an action-observation history $\\tau ^ { a } \\in T \\equiv ( Z \\times U ) ^ { * }$ , on which it conditions a policy $\\pi ^ { a } ( u ^ { a } | \\bar { \\tau } ^ { a } ) : T \\times U \\to [ 0 , 1 ]$ . We denote joint quantities over agents in bold and joint quantities over agents other than a given agent $a$ with the superscript $- a$ . ",
+        "bbox": [
+            169,
+            310,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "112 Integrated Gradients. Many works aim to attribute the predictions of deep networks to their input   \n113 features [1, 15, 2]. As one of them, integrated gradients [25] aggregates the gradients along the inputs   \n114 that fall on the lines between the baseline $\\vec { b }$ and the input ${ \\vec { x } } = ( x _ { 1 } , . . . , x _ { j } , . . . , x _ { d } )$ . It explains how   \n115 much one feature affects the deep network output $F$ while changing from $F ( \\vec { b } )$ to $F ( \\vec { x } )$ along a   \n116 path between $\\vec { b }$ and $\\vec { x }$ . Given a path function $\\tau ( \\alpha )$ with $\\alpha \\in [ 0 , 1 ]$ specifying a path from baseline   \n117 $\\tau ( 0 ) = \\vec { b }$ to the input $\\tau ( 1 ) = \\vec { x }$ , then integrated gradients along the $j ^ { t h }$ dimension is acquired by: ",
+        "bbox": [
+            140,
+            455,
+            825,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bbd72d329fef7c844efad6be73992046b6eeb530777060986dbb13e05fd6ed98.jpg",
+        "text": "$$\nc _ { j } = \\mathrm { P a t h I G } _ { j } ^ { \\tau } ( \\vec { x } ) : : = \\int _ { 0 } ^ { 1 } \\frac { \\partial F ( \\tau ( \\alpha ) ) } { \\partial \\tau _ { j } ( \\alpha ) } \\frac { \\partial \\tau _ { j } ( \\alpha ) } { \\partial \\alpha } d \\alpha ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            560,
+            661,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "118 where $c _ { j }$ represents $x _ { j }$ ’s contribution to the difference between baseline prediction $F ( \\vec { b } )$ and $F ( \\vec { x } )$ .   \n119 In this work, we leverage the integrated gradients technique to dynamically adjust the order of our   \n120 proposed sequential credit assignment according to each agent’s contribution to the team. ",
+        "bbox": [
+            142,
+            608,
+            825,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Sequential MARL Framework ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            670,
+            428,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "122 The relationship in a multi-agent system is complicated, as every agent makes decisions based on   \n123 the environment interfered with by the other agents. If we model each agent as a node and model   \n124 the cooperations between them as edges, the cooperative relationship will be built as a complicated   \n125 web-like graph shown in Figure 1(a). Evaluating the actions of any agent should take into account   \n126 the behaviors of other agents in this situation. It is hard to judge whether an agent’s current action is   \n127 beneficial to the team when we have not evaluated other agents’ actions. If we cannot determine an   \n128 analysis order, we can only analyze all the agents implicitly as most existing methods did, and the   \n129 cooperation is often fitted only by deep neural networks, leading to unsatisfactory results.   \n130 This section presents a sequential framework for cooperative MARL, which aims to analyze agents’   \n131 actions one by one. Our key assumption is that evaluations of some agents in a team are less affected   \n132 than others. Thus we can study these less-affected agents first and then analyze the others based on   \n133 the actions of these already-studied agents. For instance, when evaluating a staff’s action, the CEO’s   \n134 decision plays a vital role because we have to judge whether the staff obeys the command or not. On   \n135 the contrary, the staff intuitively has little impact on evaluating the CEO’s decision. In assessing the   \n136 CEO, we often consider external factors such as market situation, modeled as state $s$ in MARL.   \n137 We introduce a variable $\\mathcal { O } _ { i }$ to help model this sequential MARL framework. This additional variable   \n138 represents a random event that our cooperation study (e.g., credit assignment) on agent $a _ { i }$ is optimal or   \n139 precise. Then the probability $p ( \\mathcal { O } _ { i } )$ denotes the accuracy of our research on agent $a _ { i }$ . For illustration   \n140 and understanding convenience, we discuss a simple multi-agent system with three agents as an   \n141 example, in which agents are identified by $a _ { i } ( i \\in \\mathsf { \\bar { \\{ 1 , 2 , 3 \\} } } )$ . In original MARL, the evaluation of   \n142 agent $a _ { i }$ will influence all the other agents’ assessments. Thus events $\\mathcal { O } _ { 1 }$ , $\\mathcal { O } _ { 2 }$ and $\\mathcal { O } _ { 3 }$ are mutually   \n143 dependent, as shown in Figure 1(b). We calculate the probability of studying the system accurately   \n144 by computing conditional probabilities: ",
+        "bbox": [
+            140,
+            696,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c855a712f9bbbfe89c2550cc1247e89d58da7b449b5632a9d8b3b4879f2e6264.jpg",
+        "image_caption": [
+            "Figure 1: A toy example with three agents. (a) Agents affect each other as they choose actions based on the state interfered with by the others’ actions. (b) The study on one agent will influence all the other agents’ assessments in the original MARL framework. Agent’s cooperation analyses are interrelated. (c) Each agent’s cooperation study in the proposed sequential MARL framework. Dotted arrows representing correlations decrease from 6 in (b) to 3 in (c), reducing the complexity by half. This merit also holds for systems with other numbers of agents. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            85,
+            810,
+            232
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            353,
+            825,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bceab5928913d5b6c1b5bd5bd3e8b7690b379d7c2f21df28f6d0fad5b516aedd.jpg",
+        "text": "$$\n\\begin{array} { r l } { p ( \\mathcal { O } _ { 1 } , \\mathcal { O } _ { 2 } , \\mathcal { O } _ { 3 } ) = p ( \\mathcal { O } _ { 1 } ) \\cdot p ( \\mathcal { O } _ { 2 } | \\mathcal { O } _ { 1 } ) \\cdot p ( \\mathcal { O } _ { 3 } | \\mathcal { O } _ { 1 } , \\mathcal { O } _ { 2 } ) } & { { } } \\\\ { \\vdots } \\\\ { = p ( \\mathcal { O } _ { 3 } ) \\cdot p ( \\mathcal { O } _ { 2 } | \\mathcal { O } _ { 3 } ) \\cdot p ( \\mathcal { O } _ { 1 } | \\mathcal { O } _ { 2 } , \\mathcal { O } _ { 3 } ) } & { { } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            467,
+            673,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "145 where $p ( \\mathcal { O } _ { j } | \\mathcal { O } _ { i } )$ denotes the probability of agent $a _ { j }$ ’s accurate analysis under the condition of   \n146 conducting a precise study on agent $a _ { i }$ . It also indicates the accuracy of $a _ { j }$ ’s analysis conditions on   \n147 precisely assess $a _ { i }$ . We then conclude that: ",
+        "bbox": [
+            142,
+            532,
+            821,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "148 where $i , j , k \\in \\{ 1 , 2 , 3 \\} , i \\neq j , k \\neq i , j$ ",
+        "bbox": [
+            151,
+            595,
+            434,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/779eaa0e8f26e8bd5038681cd397242cbcaa189f0da5fe1090a91826f4541efa.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad p ( \\mathcal { O } _ { 1 } , \\mathcal { O } _ { 2 } , \\mathcal { O } _ { 3 } ) = p ( \\mathcal { O } _ { i } ) \\cdot p ( \\mathcal { O } _ { j } | \\mathcal { O } _ { i } ) \\cdot p ( \\mathcal { O } _ { k } | \\mathcal { O } _ { i } , \\mathcal { O } _ { j } ) } \\\\ & { , 3 \\} , i \\not = j , k \\not = i , j . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            575,
+            669,
+            613
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "149 We take Equ.(2a) as an example. To study the cooperation of this multi-agent system precisely (i.e.,   \n150 big $p ( \\mathcal { O } _ { 1 } , \\mathcal { O } _ { 2 } , \\mathcal { O } _ { 3 } ) )$ , we can first analyze $a _ { 1 }$ as accurately as possible (i.e., big $p ( \\mathcal { O } _ { 1 } ) )$ and then go   \n151 on to investigate $a _ { 2 }$ and $a _ { 3 }$ respectively with the best possible accuracy (i.e., big $\\partial ( \\mathcal { O } _ { 2 } | \\mathcal { O } _ { 1 } )$ and   \n152 $p ( \\mathcal { O } _ { 3 } | \\mathcal { O } _ { 1 } , \\mathcal { O } _ { 2 } ) )$ under the condition of preceding agents’ precise analysis.   \n153 The sequential MARL framework reduces the complexity of the model with six dotted arrows that   \n154 indicate correlations between agents’ evaluations in Figure 1(b) by half, as those three dotted lines in   \n155 Figure 1(c) show. Equ.(3) suggests that we can analyze the cooperation of a multi-agent system in   \n156 any order, but from the CEO-Staff example, we can see that the difficulty of analyzing in various   \n157 orders is not the same. Further discussion on the sequence will show in Section 3.4.   \n158 In general, we specify an order to analyze the cooperation in the sequential MARL framework. We   \n159 fix an agent’s actions after assessing it and study a particular agent based on the fixed actions of its   \n160 preceding agents, reflecting the intuition that a CEO’s decision has a strong influence on evaluating   \n161 the staff in the example mentioned earlier. This sequential MARL framework significantly alleviates   \n162 the correlations in studying agents and helps us assess their cooperation more directly. ",
+        "bbox": [
+            142,
+            616,
+            825,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            678,
+            825,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            753,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Sequential Credit Assignment ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            839,
+            421,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "64 Following the CTDE paradigm, we utilize a centralized critic for each actor to follow a gradient   \n165 based on an advantage function $A$ estimated from this critic: ",
+        "bbox": [
+            147,
+            864,
+            823,
+            893
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ec64169d50b6b63dd602fd248ca5877acaebd1af2759f8992064a4ef93e0044.jpg",
+        "text": "$$\ng = \\nabla _ { \\theta ^ { \\pi } } \\log \\pi \\left( u | \\tau _ { t } ^ { a } \\right) A .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            895,
+            581,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a7321a0ed108bed657b77946907348e4522b7b34d52af5ce5ec1f220e47d2ab.jpg",
+        "image_caption": [
+            "Figure 2: Performances between COMA’s counterfactual advantage and ours in two environments. (Left) Predator-Prey. Three predators cooperate to chase a faster prey that acts randomly in an area containing two obstacles. The game terminates when a predator captures the prey, and then a shared reward is given. The predators trained by our advantage capture the prey faster. (Right) Cooperative Navigation initializes three agents and three landmarks with random locations. Agents cooperate to cover all the landmarks, and the shared reward is the negative sum of displacements between each landmark and its nearest agent. Our method helps the team gain bigger rewards than COMA. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "166 The advantage function $A$ for each actor explicitly deduces how that particular agent contributes to   \n167 the team. COMA [6] introduced a counterfactual baseline inspired by difference rewards [34]. For   \n168 each agent $a$ , COMA computes an advantage function that compares the Q-value for the action $u ^ { a }$ to   \n169 a counterfactual baseline that marginalizes out $u ^ { a }$ while keeping the others’ actions $\\mathbf { u } ^ { - a }$ fixed: ",
+        "bbox": [
+            142,
+            358,
+            825,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72797c71b715b91f733815340d74de98531266990a54b73646c28027b4e0dec7.jpg",
+        "text": "$$\nA _ { C O M A } ^ { a } ( s , { \\mathbf { u } } ) = Q \\left( s , \\left( u ^ { a } , { \\mathbf { u } } ^ { - a } \\right) \\right) - \\sum _ { u ^ { \\prime } \\circ } \\pi ^ { a } \\left( u ^ { \\prime } { } ^ { a } | \\tau ^ { a } \\right) \\cdot Q \\left( s , \\left( { \\mathbf { u } } ^ { - a } , u ^ { \\prime } { } ^ { a } \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            417,
+            741,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "170 COMA avoids expensive calculations through careful network design. However, each agent’s   \n171 contribution deduced by COMA is still imperfect. The evaluation of $u ^ { a }$ is based on the fixed $\\mathbf { u } ^ { - a }$   \n172 in Equ.(5), so agent $a$ will learn a policy that works better with $\\mathbf { u } ^ { - a }$ in this way. It ignores the joint   \n173 actions $( u ^ { a } , \\mathbf { u } ^ { - a \\prime } )$ with $\\mathbf { u } ^ { - a \\prime } \\neq \\mathbf { u } ^ { - a }$ that may lead to unexpected results when assessing $u ^ { a }$ .   \n174 To analyze each agent $a$ ’s contribution more objectively, we consider the influence of all joint actions   \n175 with $u ^ { a }$ . Considering all potential action combinations, we calculate a counterfactual advantage for   \n176 each agent’s action, derived by computing the expectation on all the actions of other agents: ",
+        "bbox": [
+            142,
+            450,
+            825,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32e56183600c6032ce22ffbf0b42e1060062aa799383b6cbffe184a5331bb4a7.jpg",
+        "text": "$$\nA ^ { a } ( s , { \\mathbf { u } } ) = \\mathbb { E } _ { { \\mathbf { u } } ^ { - a } } \\left[ Q \\left( s , \\left( u ^ { a } , { \\mathbf { u } } ^ { - a } \\right) \\right) \\right] - \\mathbb { E } _ { { \\mathbf { u } } ^ { - a } } \\left[ \\sum _ { u ^ { \\prime } { } ^ { a } } \\pi ^ { a } \\left( u ^ { \\prime a } | \\tau ^ { a } \\right) \\cdot Q \\left( s , \\left( { \\mathbf { u } } ^ { - a } , u ^ { \\prime a } \\right) \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            556,
+            777,
+            599
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "177 Under our proposed sequential MARL framework, we carry out credit assignment according to a   \n178 specific order, and there is no need to consider all the possible joint actions. After assessing agent $a$ ,   \n179 we fix its action and evaluate agents after it based on $a$ ’s fixed action, so the following agents’ credit   \n180 assignments do not have to compute the expectation on $u ^ { a }$ anymore. ",
+        "bbox": [
+            140,
+            599,
+            826,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "181 We now give the detailed sequential credit assignment for a team with $n$ agents identified by 182 $a _ { i } ( i \\in \\{ 1 , { \\overline { { \\ldots , n } } } \\} )$ under one specific sequence $\\{ a _ { 1 } , a _ { 2 } , . . . , a _ { n } \\}$ , and it can also be concluded from the rest 183 $( n ! - 1 )$ orders in the same way. Here we denote $\\mathbf u _ { a _ { 1 } } ^ { a _ { i - 1 } } \\stackrel { \\cdot } { = } \\left[ u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } \\right]$ $( i = 2 , 3 , . . . , n )$ . ",
+        "bbox": [
+            142,
+            661,
+            826,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "184 As for agent 185 i  been deduced. We fix the leading agents’ actions and assess agent $( i \\neq 1 )$ ) in the sequence, the contribution of its leading agents $a _ { i }$ 1 2’s action based on $a _ { 1 } , a _ { 2 } , . . . , a _ { i - 1 }$ $\\mathbf { u } _ { a _ { 1 } } ^ { a _ { i - 1 } }$ has , so   \n186 there is no need to calculate the expectations on $[ u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } ]$ , simplifying Equ.(6) to: ",
+        "bbox": [
+            142,
+            709,
+            825,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/525c28e79d960db145cbed40684601575ac75c87a507fbbd5c816cce41e3cea3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle \\ = \\sum _ { u ^ { \\prime } { } ^ { a _ { i } + 1 } } \\cdot \\cdot \\cdot \\sum _ { u ^ { \\prime } { } ^ { a _ { n } } } \\pi ^ { a _ { i } + 1 } \\left( u ^ { \\prime } { } ^ { a _ { i } + 1 } \\left. \\tau ^ { a _ { i } + 1 } \\right. \\cdot \\cdot \\cdot \\pi ^ { a _ { n } } \\left( u ^ { \\prime } { } ^ { a _ { n } } \\left. \\tau ^ { a _ { n } } \\right. \\cdot \\right. \\right. Q \\left( s , \\left( \\mathbf { u } _ { a _ { 1 } } ^ { a _ { i } } , u ^ { \\prime } { } ^ { a _ { i } + 1 } , \\cdot \\cdot \\cdot , u ^ { \\prime } { } ^ { a _ { n } } \\right) \\right) \\right. } \\\\ & { \\left. \\left. \\quad - \\sum _ { u ^ { \\prime } { } ^ { a _ { i } } } \\cdot \\cdot \\cdot \\sum _ { u ^ { \\prime } { } ^ { a _ { n } } } \\pi ^ { a _ { i } } \\left( u ^ { \\prime } { } ^ { a _ { i } } \\left. \\tau ^ { a _ { i } } \\right. \\cdot \\cdot \\cdot \\pi ^ { a _ { n } } \\left( u ^ { \\prime } { } ^ { a _ { n } } \\left. \\tau ^ { a _ { n } } \\right) \\cdot Q \\left( s , \\left( \\mathbf { u } _ { a _ { 1 } } ^ { a _ { i } - 1 } , u ^ { \\prime } { } ^ { a _ { i } } , \\cdot \\cdot \\cdot \\cdot \\right. , u ^ { \\prime } { } ^ { a _ { n } } \\right) \\right) \\right. \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            755,
+            805,
+            824
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "187 Then the first agent $a _ { 1 }$ ’s advantage is: ",
+        "bbox": [
+            142,
+            824,
+            421,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb830362ce60017b7955a79b0a344d9469c1dd0f5c85b6dc62434de5bf2abb45.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { \\cal A } ^ { a _ { 1 } } \\left( s , { \\bf u } \\right) = \\sum _ { u ^ { \\prime } = 2 } \\cdots \\sum _ { u ^ { \\prime } = n } \\pi ^ { a _ { 2 } } \\left( u ^ { \\prime } { } ^ { a _ { 2 } } \\big \\vert \\tau ^ { a _ { 2 } } \\right) \\cdot \\cdot \\cdot \\pi ^ { a _ { n } } \\left( u ^ { \\prime } { } ^ { a _ { n } } \\big \\vert \\tau ^ { a _ { n } } \\right) \\cdot Q \\left( s , \\big ( u ^ { a _ { 1 } } , u ^ { \\prime } { } ^ { a _ { 2 } } , \\cdot \\cdot \\cdot , u ^ { \\prime } { } ^ { a _ { n } } \\big ) \\right) } \\ ~ } \\\\ { { \\displaystyle ~ - \\sum _ { u ^ { \\prime } = 1 } \\cdot \\cdot \\cdot \\sum _ { u ^ { \\prime } = n } \\pi ^ { a _ { 1 } } \\left( u ^ { \\prime } { } ^ { a _ { 1 } } \\big \\vert \\tau ^ { a _ { 1 } } \\right) \\cdot \\cdot \\cdot \\pi ^ { a _ { n } } \\left( u ^ { \\prime } { } ^ { a _ { n } } \\big \\vert \\tau ^ { a _ { n } } \\right) \\cdot Q \\left( s , \\big ( u ^ { \\prime } { } ^ { a _ { 1 } } , u ^ { \\prime } { } ^ { a _ { 2 } } , \\cdot \\cdot \\cdot , u ^ { \\prime } { } ^ { a _ { n } } \\big ) \\right) } \\ ~ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            840,
+            787,
+            910
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c668245e9dcfbddf169779735f299af2d0adc516e3253450dc16771d4ff9007d.jpg",
+        "image_caption": [
+            "Figure 3: (a) A centralized mixing critic network that maps the state into a set of weights (top) and the decentralized agent network structure (bottom). (b) The overall SeCA architecture. (c) Critic learning (top) and policy learning (bottom) flow. View in color if possible for better understanding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            88,
+            823,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "188 To illustrate the effectiveness of our sequential counterfactual advantage, we conduct a simple   \n189 but illuminating test in two common multi-agent particle environments [11], Predator-Prey and   \n190 Cooperative Navigation. We train both methods with 5 random seeds, and agents are trained for 5000   \n191 episodes. We provide detailed information on the environments and experiments in the Appendix. As   \n192 shown in Figure 2, our sequential advantage functions help agents handle the task faster and better.   \n93 Our sequential advantage for each agent achieves an additive decomposition of the total advantage   \n94 function, which to some extent explains the soundness and superiority of our advantage over COMA’s. ",
+        "bbox": [
+            140,
+            362,
+            825,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            156,
+            438,
+            825,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "95 Claim 1. The proposed sequential credit assignment achieves additive advantage-decomposition. ",
+        "bbox": [
+            153,
+            470,
+            812,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "196 Proof. See Appendix A. ",
+        "bbox": [
+            143,
+            500,
+            334,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "97 Facing the same problem as COMA that those evaluations are expensive, we model the first term   \n98 in Equ.(7) as a function $f _ { \\phi }$ of $\\left( u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i } } , \\pi ^ { a _ { i + 1 } } , . . . , \\pi ^ { a _ { n } } \\right)$ to address this issue, and the second   \n199 term is a similar function of $\\bigl ( u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } , \\pi ^ { a _ { i } } , . . . , \\pi ^ { a _ { n } } \\bigr ) .$ Thus, we rewrite Equ.(7) as: ",
+        "bbox": [
+            148,
+            529,
+            826,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ad007bcd5ba0b50fd386898b8359edbac7d26a2bc200d39e9dcc550d3cf2222.jpg",
+        "text": "$$\nA ^ { a _ { i } } = f _ { \\phi } \\left( s ; u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i } } , \\pi ^ { a _ { i + 1 } } , . . . , \\pi ^ { a _ { n } } \\right) - f _ { \\phi } \\left( s ; u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { i - 1 } } , \\pi ^ { a _ { i } } , . . . , \\pi ^ { a _ { n } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            575,
+            777,
+            593
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here 200 $f _ { \\phi }$ is a function evaluating agents’ action-policy vectors, where $f _ { \\phi } \\left( u ^ { a _ { 1 } } , u ^ { a _ { 2 } } , . . . , u ^ { a _ { n } } \\right) = Q$ and 201 $f _ { \\phi } \\left( \\pi ^ { a _ { 1 } } , \\pi ^ { a _ { 2 } } , . . . , \\pi ^ { a _ { n } } \\right) = V$ . We design the complete setup for SeCA, which is illustrated in Figure 3. ",
+        "bbox": [
+            150,
+            597,
+            833,
+            626
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "202 Critic Learning. We train critic $f _ { \\phi }$ on-policy to estimate $Q$ , utilizing a practical variant of $\\mathrm { T D } ( \\lambda )$ [27]   \n203 adapted for use with deep neural networks. In particular, the critic parameter $\\phi$ is updated by minibatch   \n204 gradient descent to minimize the following loss: ",
+        "bbox": [
+            140,
+            631,
+            826,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75c806bb04995cbf6e00ff581013df87ab230a24777fff1e7b2d60d3e84ff43a.jpg",
+        "text": "$$\n\\mathcal { L } _ { t } ( \\phi ) = \\left( y _ { t } ^ { ( \\lambda ) } - f _ { \\phi } ( s _ { t } , \\mathbf { u } _ { t } ) \\right) ^ { 2 } , \\mathrm { ~ w h e r e ~ } y _ { t } ^ { ( \\lambda ) } = r _ { t } + \\gamma \\left( \\lambda y _ { t + 1 } ^ { ( \\lambda ) } + ( 1 - \\lambda ) f _ { \\phi ^ { - } } ( s _ { t + 1 } , \\mathbf { u } _ { t + 1 } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            678,
+            784,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "205 We utilize a target critic $f _ { \\phi ^ { - } }$ [14] to improve learning stability and update ${ \\phi } ^ { - }  \\phi$ periodically. The   \n206 critic learning flow is shown at the top of Figure 3(c). The input for critic training is the state $s$ and   \n207 the action vector $\\mathbf { u } = \\left[ u ^ { 1 } , u ^ { 2 } , . . . , u ^ { n } \\right]$ denoted as $\\mathbf { v } ^ { 1 : n }$ .   \n208 Policy Learning. We optimize each agent $a$ ’s policy parameter $\\theta _ { a }$ by maximizing the following   \n209 objective, which contains our proposed advantage function and an entropy regularization term $\\mathcal { H }$ : ",
+        "bbox": [
+            140,
+            713,
+            826,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            761,
+            825,
+            790
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d93e82adc93ab363671bab4935f0805faa6eef6b33d0e80154297410997967b.jpg",
+        "text": "$$\ng ^ { a } = \\mathbb { E } _ { \\tau \\sim \\pi } \\left[ \\nabla _ { \\theta _ { a } } \\log \\pi ^ { a } ( u ^ { a } | \\tau ^ { a } ) A ^ { a } ( s , \\mathbf { u } ) + \\mathcal { H } \\left( \\pi ^ { a } ( \\cdot | \\tau ^ { a } ) \\right) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            792,
+            689,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where the derivative of the adaptive entropy regularization term 210 $\\mathcal { H } ( \\pi ^ { a } ( \\cdot | \\tau ^ { a } ) )$ [39] with respect to the 211 $i$ -th action probability $p _ { i } ^ { a }$ is given by: ",
+        "bbox": [
+            150,
+            815,
+            825,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1db4309fafa77207a654fe0efd2ff683110b27b1dbebe65e18e1dd0047d308e3.jpg",
+        "text": "$$\n\\begin{array} { r } { d \\mathcal { H } _ { i } : = - \\xi \\cdot ( \\log p _ { i } ^ { a } + 1 ) / H ( \\pi ^ { a } ( \\cdot | \\tau ^ { a } ) ) , \\mathrm { ~ w h e r e ~ } H ( \\pi ^ { a } ( \\cdot | \\tau ^ { a } ) ) = \\mathbb { E } _ { u ^ { a } \\sim \\pi ^ { a } } \\left[ - \\log \\pi ^ { a } ( u ^ { a } | \\tau ^ { a } ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            848,
+            789,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "212 We share parameters among agents, and the gradient we use to train the actor shared by all agents is: ",
+        "bbox": [
+            145,
+            869,
+            820,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67789cf906fe8381d26c855f654dc708d81b14e5f3fbb37628109e375c75fa9a.jpg",
+        "text": "$$\ng = \\mathbb { E } _ { \\tau \\sim \\pi } \\left[ \\sum _ { a } \\left( \\nabla _ { \\theta _ { a } } \\log \\pi ^ { a } ( u ^ { a } | \\tau ^ { a } ) A ^ { a } ( s , \\mathbf { u } ) + \\mathcal { H } \\left( \\pi ^ { a } ( \\cdot | \\tau ^ { a } ) \\right) \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            888,
+            714,
+            916
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "213 The inputs of the centralized critic $f _ { \\phi }$ to compute the advantage function are the state $s$ and two   \n214 action-policy vectors $\\mathbf { v } ^ { 1 : i } = \\left[ u ^ { 1 } , . . . , \\dot { u } ^ { i } , \\pi ^ { i + 1 } , . . . , \\pi ^ { n } \\right]$ and $\\mathbf { v } ^ { 1 : i - \\bar { 1 } } = \\left[ u ^ { 1 } , . . . , u ^ { i - 1 } , \\pi ^ { i } , . . . , \\pi ^ { n } \\right]$ . The   \n215 bottom of Figure 3(c) demonstrates the policy learning flow. ",
+        "bbox": [
+            142,
+            92,
+            825,
+            136
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Sequence Adjustment Through Integrated Gradients ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            150,
+            581,
+            165
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We apply integrated gradients to adjust the credit assignment sequence dynamically. Reviewing the enlightening and straightforward CEO-Staff example discussed in Section 3.2, we can evaluate the staff’s behavior based on the CEO’s decision, but assessing the CEO does not require much attention to the staff’s action. Therefore, we would analyze the CEO first and then evaluate the staff based on the CEO’s current action. However, this example is not generalized for two reasons: (1) There are often multiple agents taking the same role in a system with superior-subordinate relationships, and the sequence of these agents is hard to determine; (2) Not all scenarios have such superior-subordinate relationships. The agents often do not need to follow others’ commands in many applications. ",
+        "bbox": [
+            171,
+            175,
+            825,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "225 We generalize the CEO-Staff example to propose a universal model. Instead of focusing on the roles   \n226 among the agents as in [31, 32], we are more interested in agents’ contributions. Although the CEO   \n227 and the staff have a superior-subordinate relationship, they are essentially employees of an enterprise.   \n228 The staff plays an auxiliary role and acts based on the CEO’s decision. The staff’s work is meaningful   \n229 only if the CEO’s decision is correct. Therefore, we often intuitively assume that an enterprise’s   \n230 leader is paid more and contributes more. Based on this, we transform the roles of the CEO and staff   \n231 into employees with different contributions to the enterprise. In the sequential MARL framework, we   \n232 first assign credit to the agent with a higher contribution to the team.   \n233 The attribution method is a powerful way to determine the influence of input features’ each component   \n234 on the network output value [2]. Among them, integrated gradients [25] leverages path integral to   \n235 aggregate gradients along the inputs that fall on the lines between the baseline and the input, which   \n236 is a natural tool for measuring each agent’s contribution. QPD [35] utilizes the integrated gradient   \n237 attribution technique to decompose shared rewards along trajectory paths, revealing how much each   \n238 agent’s observation and action contributes to the global Q value. However, it remains unclear whether   \n239 individual Q value should be linearly correlated to or approximated by the agent’s contribution, as in   \n240 the case of QPD. The proper connection between agents’ contributions and their individual Q values   \n241 in a cooperative team is worth well studied for the community. ",
+        "bbox": [
+            140,
+            292,
+            825,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            410,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here we avoid detailed analysis on the relationship between agents’ contributions and their individual rewards. Instead, we use integrated gradients to measure agents’ contributions to the state transition and adjust the credit assignment sequence based on their contributions. In particular, we estimate agent $a$ ’s contribution $c ^ { a }$ in the trajectory path $\\tau _ { t _ { 1 } } ^ { t _ { 2 } }$ from time $t _ { 1 }$ to $t _ { 2 }$ based on its policy vector $\\pi ^ { a }$ : ",
+        "bbox": [
+            163,
+            541,
+            823,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14e1f3b1396df06717f0906ef58832e847a3e59f928fd225a202866627741baa.jpg",
+        "text": "$$\nc ^ { a } = \\sum _ { x _ { j } \\in \\pi ^ { a } } \\mathrm { P a t h I G } _ { j } ^ { \\tau _ { t _ { 1 } } ^ { t _ { 2 } } } ( \\pi ^ { a } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            601,
+            593,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "246 where $x _ { j }$ is $j$ -th dimension of the policy vector $\\pi ^ { a }$ . The computation for PathIG is shown in Equ.(1).   \n247 We compute each agent’s contribution $c$ to the state transition from $s _ { t _ { 1 } }$ to $s _ { t _ { 2 } }$ and analyze the agent   \n248 with higher $c$ first. We further study the adjustment frequency and its effectiveness in Section 4.2 ",
+        "bbox": [
+            142,
+            642,
+            825,
+            685
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments and Analysis ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            703,
+            424,
+            720
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            733,
+            351,
+            748
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider a challenging set of cooperative StarCraft II maps from the SMAC benchmark [23] classified as Easy, Hard, and Super Hard scenarios according to the baseline algorithms’ performance. The inherent differences among various methods and their training procedure (e.g., on/off-policy learning for value-based/policy-based methods) bring difficulties when comparing methods in a reasonably fair manner without introducing additional components (e.g., importance sampling [13, 33] for off-policy methods). To attribute any poor performance of policy-based methods to potential algorithmic limitations or poor training conditions (in particular, high variance due to small batch sizes or insufficient gradient steps), we follow [5, 39], training all methods with 32 parallel runners to generate trajectories and using batches of 32 episodes. We evaluate each method every 320K steps with 32 episodes and report the 1st, median, and 3rd quartile win rates across 5 random seeds. Detailed information about the scenarios and the experimental setup is shown in the Appendix. ",
+        "bbox": [
+            169,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1136df9f6bcfaf9c4dc17813aee3a729a186de53396fdc91896a637a666edaf4.jpg",
+        "image_caption": [
+            "Figure 4: Ablations for SeCA’s key elements on scenario MMM2 (Super Hard). (a) investigates the effects of our sequential advantage and network architecture. (b) validates our sequence adjustment through integrated gradients. (c) shows the test win percentage with various adjustment frequencies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            825,
+            210
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            292,
+            326,
+            306
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first carry out ablation experiments on a Super Hard map MMM2 to validate key elements of SeCA. ",
+        "text_level": 1,
+        "bbox": [
+            160,
+            319,
+            823,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Proposed Advantage and Architecture. In Section 3.3, we compare our sequential advantage with COMA’s in two simple multi-agent particle environments and show our superiority in Figure 2. Afterward, we introduce a $f _ { \\phi }$ approximation and a corresponding network architecture. Here we apply the same approximation and architecture for COMA’s counterfactual advantage (COMA-newArchi) and compare it with the original COMA and our method SeCA to show the effects of our advantage function, approximation, and network architecture. The result is illustrated in Figure 4(a). COMA performs poorly on this Super Hard map but acquires significant improvement with our approximation and architecture. Our sequential advantage further accelerates and stabilizes the training. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sequence Adjustment Algorithm. SeCA’s credit assignment sequence is dynamic. We compare our method with some intuitive adjustments to validate its effects. One could first evaluate agents with higher current-action probability (SeCA-Prob) or lower policy entropy (SeCA-Entro), as these agents are more confident in their acts, and we can assess other agents based on their behaviors. Since SeCA-Prob and Entro get a new order at each step, to be fair, we set the path length in Equ.(14) to one, i.e., consider agents’ contributions based on the transition from $s _ { t }$ to $s _ { t + 1 }$ (SeCA-IG-1). Figure 4(b) illustrates that SeCA-Prob and Entro learn better than the fixed method (SeCA-Fixed), but Prob has a larger variance than Entro. Fixed is better than expected, which we believe is because that the fixed sequence acquires adequate training. Our integrated-gradients-adjustment performs the best in win rates and stability, and the others have inferior performance and incredibly high variance. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            594
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sequence Adjustment Frequency. We next consider how the sequence adjustment frequency in SeCA-IG affects the performance. Except per step adjustment (i.e., SeCA-IG-1), one could also update the sequence after a stage or an episode. If we change the credit assignment order for every episode during training (SeCA-IG-episode), then $\\tau _ { t _ { 1 } } ^ { t _ { 2 } }$ in Equ.(14) represents a whole episode. As for stage adjustment, it is hard to define a stage in these tasks, and the stage length varies in diverse maps. Here we set stage length to 10 and 20, respectively denoted as SeCA-IG-10 and SeCA-IG-20. As the results in Figure 4(c) show, IG-1 and IG-episode have similar final win rates. However, IG-episode converges more quickly with smaller variance. The reason for IG-10(20)’s mediocre performance and high variance may be because the stage length needs to be dynamically adjusted. Inappropriate adjustment frequency fails to adapt to the stage changes in the task and causes insufficient training for each sequence. We utilized SeCA-IG-episode in other experiments and will investigate dynamic stage learning in the future to improve stage adjustment. ",
+        "bbox": [
+            163,
+            602,
+            825,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "94 4.3 Comparisons with State-of-the-arts ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            787,
+            457,
+            801
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare SeCA with some competitive algorithms, including the representative explicit credit assignment method COMA, the policy-based implicit method LICA, the common-used baseline QMIX and QTRAN. Methods are evaluated on 6 scenarios, including 2 Easy ones (2s3z, 1c3s5z), 2 Hard ones $( 2 \\mathsf { c } _ { - } \\mathsf { v s } _ { - } 6 4 \\mathsf { z g } , 3 \\mathsf { s } _ { - } \\mathsf { v s } _ { - } 5 \\mathsf { z } )$ , and 2 Super Hard ones (MMM2, $ { 3 \\mathbf { s } } 5  { \\mathbf { z } } _ { - }  { \\mathbf { v } }  { \\mathbf { s } } _ { - } 3  { \\mathbf { s } } 6 z ,$ . We train all methods for 32 million steps in Easy maps and 64 million steps in Hard and Super Hard maps. These scenarios involve homogeneous and heterogeneous teams, symmetric and asymmetric battles, allowing a holistic study on all methods. Our experiments are based on the latest PyMARL [23] ",
+        "bbox": [
+            165,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/38587f1c30280214c4c2e9ac29dc02023f61d16f0bacb03b84a7241ac6bc2863.jpg",
+        "image_caption": [
+            "Figure 5: The comparison of SeCA against various baseline algorithms on six SMAC maps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            85,
+            825,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "302 utilizing SC2.4.10. Performance is not always comparable between versions, so the results may be   \n303 subtly different from the original papers.   \n304 As we can see in Figure 5, SeCA demonstrates its robustness by achieving good performances in   \n305 scenarios with various characteristics. All methods except COMA and QTRAN solve two Easy   \n306 scenarios, and SeCA performs better in convergence speed and stability. SeCA’s advantage is further   \n307 extended in the Hard map $\\mathsf { 2 c _ { - } v s _ { - } 6 4 z g }$ , and it converges significantly faster than other methods.   \n308 Although classified only as Hard, $ { 3 \\mathrm { s } } _ { - }  { \\mathrm { v } }  { \\mathrm { s } } _ { - }  { 5 z }$ invalidates most algorithms except QMIX and SeCA, as   \n309 Stalkers have to learn dispersing and making enemies give chase while maintaining enough distance   \n310 (\"kiting\" technique) in this map. SeCA has a higher variance than QMIX. This is possibly because   \n311 the Stalkers’ scattering prioritizes individual performance over cooperation which is more in line   \n312 with QMIX’s monotonicity constraint. Nevertheless, SeCA’s performance improvements on the   \n313 Super Hard scenarios MMM2 and $ { 3 \\mathbf { s } } 5  { \\mathbf { z } } _ { - }  { \\mathbf { v } }  { \\mathbf { s } } _ { - } 3  { \\mathbf { s } } 6  { \\mathbf { z } }$ demonstrate the effectiveness of our method. LICA’s   \n314 performance in $ { 3 \\mathbf { s } } 5  { \\mathbf { z } } _ { - }  { \\mathbf { v } }  { \\mathbf { s } } _ { - } 3  { \\mathbf { s } } 6  { \\mathbf { z } }$ here is different from the original paper, as the original results for   \n315 this map are obtained by using a different entropy coefficient, which is explained in its open-source   \n316 implementation.1 This parameter tuning is unfair when comparing methods, so all experiments in this   \n317 paper use the fixed entropy coefficient. We also visualize the learned sequences in different battles of   \n318 $3 { \\bf s } _ { - } \\mathtt { v } { \\bf s } _ { - } 5 z$ to provide insights into our sequence adjustment in the Appendix.   \n19 We are supposed to compare our method with QPD that also utilizes integrated gradients to show   \n320 our improvement. However, QPD modifies the original SMAC environment to acquire additional   \n321 information for policy training, which is mentioned in its open-source implementation.2 Therefore, it   \n322 is unfair to compare QPD’s learning curves in the modified environment with other methods, and   \n323 QPD’s authors did not provide methods’ learning curves comparison in the original paper. We follow   \n324 them, providing a win rate table in the Appendix to show our superiority over QPD. ",
+        "bbox": [
+            142,
+            385,
+            823,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            419,
+            825,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            632,
+            825,
+            717
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            734,
+            459,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This paper presents SeCA, a cooperative MARL framework with sequential credit assignment. SeCA computes counterfactual advantage functions to evaluate each agent based on the actions of the preceding agents under a specific sequence. The sequence is adjusted dynamically according to agents’ contributions to the team deduced by integrated gradients. SeCA accelerates policy convergence and improves the final performance over existing recognized methods in practice. In the future, we will further investigate stage learning in an episode and adjust the sequence per stage to improve SeCA and achieve adaptive cooperation in various task situations. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Marco Ancona, Enea Ceolini, Cengiz Öztireli, and Markus Gross. Towards better understanding of gradient-based attribution methods for deep neural networks. In International Conference on Learning Representations, 2018.   \n[2] Guillem Brasó Andilla. Attribution methods for deep convolutional networks.   \n[3] Yongcan Cao, Wenwu Yu, Wei Ren, and Guanrong Chen. An overview of recent progress in the study of distributed multi-agent coordination. IEEE Transactions on Industrial informatics, 9(1):427–438, 2012.   \n[4] Yu-han Chang, Tracey Ho, and Leslie Kaelbling. All learning is local: Multi-agent learning in global reward games. In Advances in Neural Information Processing Systems, pages 808–814, 2004.   \n[5] Yali Du, Lei Han, Meng Fang, Ji Liu, Tianhong Dai, and Dacheng Tao. Liir: Learning individual intrinsic reward in multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pages 4403–4414, 2019.   \n[6] Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In AAAI Conference on Artificial Intelligence, pages 2974–2982, 2018.   \n[7] Jayesh K Gupta, Maxim Egorov, and Mykel Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In International Conference on Autonomous Agents and Multiagent Systems, pages 66–83, 2017.   \n[8] Pablo Hernandez-Leal, Bilal Kartal, and Matthew E Taylor. A survey and critique of multiagent deep reinforcement learning. Autonomous Agents and Multi-Agent Systems, 33(6):750–797, 2019.   \n[9] Maximilian Hüttenrauch, Adrian Šošic, and Gerhard Neumann. Guided deep reinforcement ´ learning for swarm systems. In AAMAS Autonomous Robots and Multirobot Systems (ARMS) Workshop, 2017.   \n[10] Landon Kraemer and Bikramjit Banerjee. Multi-agent reinforcement learning as a rehearsal for decentralized planning. Neurocomputing, 190:82–94, 2016.   \n[11] Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pages 6382–6393, 2017.   \n[12] Anuj Mahajan, Tabish Rashid, Mikayel Samvelyan, and Shimon Whiteson. Maven: Multiagent variational exploration. In Advances in Neural Information Processing Systems, pages 7611–7622, 2019.   \n[13] A Rupam Mahmood, Hado van Hasselt, and Richard S Sutton. Weighted importance sampling for off-policy learning with linear function approximation. In Advances in Neural Information Processing Systems, pages 3014–3022, 2014.   \n[14] 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–533, 2015.   \n[15] Grégoire Montavon, Wojciech Samek, and Klaus-Robert Müller. Methods for interpreting and understanding deep neural networks. Digital Signal Processing, 73:1–15, 2018.   \n[16] Frans A Oliehoek and Christopher Amato. A concise introduction to decentralized POMDPs. Springer, 2016.   \n[17] Frans A Oliehoek, Matthijs TJ Spaan, and Nikos Vlassis. Optimal and approximate q-value functions for decentralized pomdps. Journal of Artificial Intelligence Research, 32:289–353, 2008.   \n380 [18] Afshin OroojlooyJadid and Davood Hajinezhad. A review of cooperative multi-agent deep reinforcement learning. arXiv preprint arXiv:1908.03963, 2019.   \n382 [19] Gregory Palmer, Karl Tuyls, Daan Bloembergen, and Rahul Savani. Lenient multi-agent deep reinforcement learning. In International Conference on Autonomous Agents and MultiAgent Systems, pages 443–451, 2018. [20] Scott Proper and Kagan Tumer. Modeling difference rewards for multiagent learning. In International Conference on Autonomous Agents and Multi-Agent Systems, pages 1397–1398, 2012.   \n388 [21] Tabish Rashid, Gregory Farquhar, Bei Peng, and Shimon Whiteson. Weighted qmix: Expanding monotonic value function factorisation. In Advances in Neural Information Processing Systems, pages 10199–10210, 2020. [22] Tabish Rashid, Mikayel Samvelyan, Christian Schroeder, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: Monotonic value function factorisation for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pages 4295–4304, 2018. [23] Mikayel Samvelyan, Tabish Rashid, Christian Schroeder de Witt, Gregory Farquhar, Nantas Nardelli, Tim G. J. Rudner, Chia-Man Hung, Philiph H. S. Torr, Jakob Foerster, and Shimon Whiteson. The starcraft multi-agent challenge. CoRR, abs/1902.04043, 2019.   \n398 [24] Kyunghwan Son, Daewoo Kim, Wan Ju Kang, David Earl Hostallero, and Yung Yi. Qtran: Learning to factorize with transformation for cooperative multi-agent reinforcement learning. In International Conference on Machine Learning, pages 5887–5896, 2019. [25] Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In International Conference on Machine Learning, pages 3319–3328, 2017. [26] Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Valuedecomposition networks for cooperative multi-agent learning based on team reward. In International Conference on Autonomous Agents and MultiAgent Systems, pages 2085–2087, 2018. [27] Richard S Sutton. Learning to predict by the methods of temporal differences. Machine learning, 3(1):9–44, 1988.   \n410 [28] Kagan Tumer and Adrian Agogino. Distributed agent-based air traffic flow management. In International Joint Conference on Autonomous Agents and Multiagent Systems, pages 1–8, 2007. [29] Jianhao Wang, Zhizhou Ren, Terry Liu, Yang Yu, and Chongjie Zhang. Qplex: Duplex dueling multi-agent q-learning. arXiv preprint arXiv:2008.01062, 2020. [30] Jianhong Wang, Yuan Zhang, Tae-Kyun Kim, and Yunjie Gu. Shapley q-value: A local reward approach to solve global reward games. In AAAI Conference on Artificial Intelligence, pages 7285–7292, 2020. [31] Tonghan Wang, Heng Dong, Victor Lesser, and Chongjie Zhang. Roma: Multi-agent reinforcement learning with emergent roles. In International Conference on Machine Learning, pages 9876–9886, 2020. [32] Tonghan Wang, Tarun Gupta, Anuj Mahajan, Bei Peng, Shimon Whiteson, and Chongjie Zhang. Rode: Learning roles to decompose multi-agent tasks. arXiv preprint arXiv:2010.01523, 2020. [33] Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. arXiv preprint arXiv:1611.01224, 2016. [34] David H Wolpert and Kagan Tumer. Optimal payoff functions for members of collectives. In Modeling complexity in economic and social systems, pages 355–369. World Scientific, 2002.   \n[35] Yaodong Yang, Jianye Hao, Guangyong Chen, Hongyao Tang, Yingfeng Chen, Yujing Hu, Changjie Fan, and Zhongyu Wei. Q-value path decomposition for deep multiagent reinforcement learning. In International Conference on Machine Learning, pages 10706–10715, 2020.   \n[36] Dayong Ye, Minjie Zhang, and Yun Yang. A multi-agent framework for packet routing in wireless sensor networks. Sensors, 15(5):10026–10047, 2015.   \n[37] Wang Ying and Sang Dayong. Multi-agent framework for third party logistics in e-commerce. Expert Systems with Applications, 29(2):431–436, 2005.   \n[38] Kaiqing Zhang, Zhuoran Yang, and Tamer Ba¸sar. Multi-agent reinforcement learning: A selective overview of theories and algorithms. arXiv preprint arXiv:1911.10635, 2019.   \n[39] Meng Zhou, Ziyu Liu, Pengwei Sui, Yixuan Li, and Yuk Ying Chung. Learning implicit credit assignment for cooperative multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            160,
+            56,
+            828,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            87,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            166,
+            90,
+            828,
+            300
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            160,
+            325,
+            254,
+            342
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            353,
+            341,
+            367
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] We discussed it in the experiment analysis in Section 4.3 and future work in Section 5.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            372,
+            825,
+            477
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            481,
+            493,
+            496
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] We provided the proof of our Claim in the supplemental material. ",
+        "bbox": [
+            236,
+            500,
+            825,
+            545
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            549,
+            393,
+            564
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We provided our code and instructions in the supplemental material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We described the training details in the supplemental material.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Figure 2, 4 and 5.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We described it in the supplemental material. ",
+        "bbox": [
+            238,
+            569,
+            825,
+            714
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            719,
+            823,
+            734
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [Yes]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provided our code in the supplemental material.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            738,
+            825,
+            859
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            864,
+            707,
+            878
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] ",
+        "bbox": [
+            235,
+            883,
+            826,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "476 (b) Did you describe any potential participant risks, with links to Institutional Review   \n477 Board (IRB) approvals, if applicable? [N/A]   \n478 (c) Did you include the estimated hourly wage paid to participants and the total amount   \n479 spent on participant compensation? [N/A] ",
+        "bbox": [
+            137,
+            90,
+            825,
+            151
+        ],
+        "page_idx": 12
+    }
+]

parse/train/LWH-C1HoQG_/LWH-C1HoQG_.md

@@ -0,0 +1,243 @@
+# Few-Shot Segmentation via Cycle-Consistent Transformer
+
+Gengwei Zhang1,2∗, Guoliang Kang3, Yi Yang4, Yunchao Wei5,6† 1 Baidu Research   
+2 ReLER, Centre for Artificial Intelligence, University of Technology Sydney 3 University of Texas, Austin   
+4 CCAI, College of Computer Science and Technology, Zhejiang University 5 Institute of Information Science, Beijing Jiaotong University 6 Beijing Key Laboratory of Advanced Information Science and Network {zgwdavid, kgl.prml, wychao1987, yee.i.yang} $@$ gmail.com
+
+# Abstract
+
+Few-shot segmentation aims to train a segmentation model that can fast adapt to novel classes with few exemplars. The conventional training paradigm is to learn to make predictions on query images conditioned on the features from support images. Previous methods only utilized the semantic-level prototypes of support images as the conditional information. These methods cannot utilize all pixel-wise support information for the query predictions, which is however critical for the segmentation task. In this paper, we focus on utilizing pixel-wise relationships between support and query images to facilitate the few-shot segmentation task. We design a novel Cycle-Consistent TRansformer (CyCTR) module to aggregate pixel-wise support features into query ones. CyCTR performs cross-attention between features from different images, i.e. support and query images. We observe that there may exist unexpected irrelevant pixel-level support features. Directly performing cross-attention may aggregate these features from support to query and bias the query features. Thus, we propose using a novel cycle-consistent attention mechanism to filter out possible harmful support features and encourage query features to attend to the most informative pixels from support images. Experiments on all few-shot segmentation benchmarks demonstrate that our proposed CyCTR leads to remarkable improvement compared to previous state-of-the-art methods. Specifically, on Pascal- ${ \mathrm { ~ \bar { \cdot } ~ } } 5 ^ { i }$ and $\mathrm { C O C O - } \bar { 2 } 0 ^ { i }$ datasets, we achieve $6 7 . 5 \%$ and $4 5 . 6 \%$ mIoU for 5-shot segmentation, outperforming previous state-of-the-art method by $5 . 6 \%$ and $7 . 1 \%$ respectively.
+
+# 1 Introduction
+
+Recent years have witnessed great progress in semantic segmentation [19, 4, 47]. The success can be largely attributed to large amounts of annotated data [48, 17]. However, labeling dense segmentation masks are very time-consuming [45]. Semi-supervised segmentation [15, 39, 38] has been broadly explored to alleviate this problem, which assumes a large amount of unlabeled data is accessible. However, semi-supervised approaches may fail to generalize to novel classes with very few exemplars. In the extreme low data regime, few-shot segmentation [26, 35] is introduced to train a segmentation model that can quickly adapt to novel categories.
+
+![](images/3515756eb6376bef3d1c8d8fbc89702c1c6040d2db9781f39f3b540cf852b6b7.jpg)  
+Figure 1: Different learning frameworks for few-shot segmentation, from the perspective of ways to utilize support information. (a) Class-wise mean pooling based method. (b) Clustering based method. (c) Foreground pixel attention method. (d) Our Cycle-Consistent TRansformer (CyCTR) framework that enables all beneficial support pixel-level features (foreground and background) to be considered.
+
+Most few-shot segmentation methods follow a learning-to-learn paradigm where predictions of query images are made conditioned on the features and annotations of support images. The key to the success of this training paradigm lies in how to effectively utilize the information provided by support images. Previous approaches extract semantic-level prototypes from support features and follow a metric learning [29, 7, 35] pipeline extending from PrototypicalNet [28]. According to the granularity of utilizing support features, these methods can be categorized into two groups, as illustrated in Figure 1: 1) Class-wise mean pooling [35, 46, 44] (Figure 1(a)). Support features within regions of different categories are averaged to serve as prototypes to facilitate the classification of query pixels. 2) Clustering [18, 41] (Figure 1(b)). Recent works attempt to generate multiple prototypes via EM algorithm or K-means clustering [41, 18], in order to extract more abundant information from support images. These prototype-based methods need to “compress" support information into different prototypes (i.e. class-wise or cluster-wise), which may lead to various degrees of loss of beneficial support information and thus harm segmentation on query image. Rather than using prototypes to abstract the support information, [43, 34] (Figure 1(c)) propose to employ the attention mechanism to extract information from support foreground pixels for segmenting query. However, such methods ignore all the background support pixels that can be beneficial for segmenting query image, and incorrectly consider partial foreground support pixels that are quite different from the query ones, leading to sub-optimal results.
+
+In this paper, we focus on equipping each query pixel with relevant information from support images to facilitate the query pixel classification. Inspired by the transformer architecture [32] which performs feature aggregation through attention, we design a novel Cycle-Consistent Transformer (CyCTR) module (Figure 1(d)) to aggregate pixel-wise support features into query ones. Specifically, our CyCTR consists of two types of transformer blocks: the self-alignment block and the cross-alignment block. The selfalignment block is employed to encode the query image features by aggregating its relevant context information, while the cross-alignment aims to aggregate the pixel-wise features of support images into the pixel-wise features of query image. Different from self-alignment where Query3, Key and Value come from the same
+
+![](images/4176acdf25fe22f9afc4fcfddcb55cb3d6c27e425d48ce4e279f955abbe2f6b4.jpg)  
+Figure 2: The motivation of our proposed method. Many pixel-level support features are quite different from the query ones, and thus may confuse the attention. We incorporate cycle-consistency into attention to filter such confusing support features. Note that the confusing support features may come from foreground and background.
+
+embedding, cross-alignment takes features from query images as Query, and those from support images as Key and Value. In this way, CyCTR provides abundant pixel-wise support information for pixel-wise features of query images to make predictions.
+
+Moreover, we observe that due to the differences between support and query images, e.g., scale, color and scene, only a small proportion of support pixels can be beneficial for the segmentation of query image. In other words, in the support image, some pixel-level information may confuse the attention in the transformer. Figure 2 provides a visual example of a support-query pair together with the label masks. The confusing support pixels may come from both foreground pixels and background pixels. For instance, point $p _ { 1 }$ in the support image located in the plane afar, which is indicated as foreground by the support mask. However, the nearest point $p _ { 2 }$ in the query image (i.e. $p _ { 2 }$ has the largest feature similarity with $p _ { 1 }$ ) belongs to a different category, i.e. background. That means, there exists no query pixel which has both high similarity and the same semantic label with $p _ { 1 }$ . Thus, $p _ { 1 }$ is likely to be harmful for segmenting "plane" and should be ignored when performing the attention. To overcome this issue, in CyCTR, we propose to equip the cross-alignment block with a novel cycle-consistent attention operation. Specifically, as shown in Figure 2, starting from the feature of one support pixel, we find its nearest neighbor in the query features. In turn, this nearest neighbor finds the most similar support feature. If the starting and the end support features come from the same category, a cycle-consistency relationship is established. We incorporate such an operation into attention to force query features only attend to cycle-consistent support features to extract information. In this way, the support pixels that are far away from query ones are not considered. Meanwhile, cycle-consistent attention enables us to more safely utilize the information from background support pixels, without introducing much bias into the query features.
+
+In a nutshell, our contributions are summarized as follows: (1) We tackle few-shot segmentation from the perspective of providing each query pixel with relevant information from support images through pixel-wise alignment. (2) We propose a novel Cycle-Consistent TRansformer (CyCTR) to aggregate the pixel-wise support features into the query ones. In CyCTR, we observe that many support features may confuse the attention and bias pixel-level feature aggregation, and propose incorporating cycle-consistent operation into the attention to deal with this issue. (3) Our CyCTR achieves state-ofthe-art results on two few-shot segmentation benchmarks, i.e., Pascal- $5 ^ { i }$ and COCO- $2 0 ^ { i }$ . Extensive experiments validate the effectiveness of each component in our CyCTR.
+
+# 2 Related Work
+
+# 2.1 Few-Shot Segmentation
+
+Few-shot segmentation [26] is established to perform segmentation with very few exemplars. Recent approaches formulate few-shot segmentation from the view of metric learning [29, 7, 35]. For instance, [7] first extends PrototypicalNet [28] to perform few-shot segmentation. PANet [35] simplifies the framework with an efficient prototype learning framework. SG-One [46] leverage the cosine similarity map between the single support prototype and query features to guide the prediction. CANet [44] replaces the cosine similarity with an additive alignment module and iteratively refines the network output. PFENet [30] further designs an effective feature pyramid module and leverages a prior map to achieve better segmentation performance. Recently, [41, 18, 43] point out that only a single support prototype is insufficient to represent a given category. Therefore, they attempt to obtain multiple prototypes via EM algorithm to represent the support objects and the prototypes are compared with query image based on cosine similarity [18, 41]. Besides, [43, 34] attempt to use graph attention networks [33, 40] to utilize all foreground support pixel features. However, they ignore all pixels in the background region by default. Besides, due to the large difference between support and query images, not all support pixels will benefit final query segmentation. Recently, some concurrent works propose to learn dense matching through Hypercorrelation Squeeze Networks [22] or mining latent classes [42] from the background region. Our work aims at mining information from the whole support image, but exploring to use the transformer architecture and from a different perspective, i.e., reducing the noise in the support pixel-level features.
+
+# 2.2 Transformer
+
+Transformer and self-attention were firstly introduced in the fields of machine translation and natural language processing [6, 32], and are receiving increasing interests recently in the computer vision area. Previous works utilize self-attention as additional module on top of existing convolutional networks, e.g., Nonlocal [36] and CCNet [14]. ViT [8] and its following work [31] demonstrate the pure transformer architecture can achieve state-of-the-art for image recognition. On the other hand, DETR [3] builds up an end-to-end framework with a transformer encoder-decoder on top of backbone networks for object detection. And its deformable vairents [51] improves the performance and training efficiency. Besides, in natural language processing, a few works [2, 5, 27] have been introduced for long documents processing with sparse transformers. In these works, each Query token only attends to a pre-defined subset of Key positions.
+
+# 2.3 Cycle-consistency Learning
+
+Our work is partially inspired by cycle-consistency learning [50, 9] that is explored in various computer vision areas. For instance, in image translation, CycleGAN [50] uses cycle-consistency to align image pairs. It is also effective in learning 3D correspondence [49], consistency between video frames [37] and association between different domains [16]. These works typically constructs cycle-consistency loss between aligned targets (e.g., images). However, the simple training loss cannot be directly applied to few-shot segmentation because the test categories are unseen from the training process and no finetuning is involved during testing. In this work, we incorporate the idea of cycle-consistency into transformer to eliminate the negative effect of confusing or irrelevant support pixels.
+
+# 3 Methodology
+
+# 3.1 Problem Setting
+
+Few-shot segmentation aims at training a segmentation model that can segment novel objects with very few annotated samples. Specifically, given dataset $D _ { t r a i n }$ and $D _ { t e s t }$ with category set $C _ { t r a i n }$ and $C _ { t e s t }$ respectively, where $C _ { t r a i n } \cap C _ { t e s t } = { \emptyset }$ , the model trained on $D _ { t r a i n }$ is directly used to test on $D _ { t e s t }$ . In line with previous works [30, 35, 44], episode training is adopted in this work for few-shot segmentation. Each episode is composed of $k$ support images $I _ { s }$ and a query image $I _ { q }$ to form a $k$ -shot episode $\{ \{ I _ { s } \} ^ { k } , I _ { q } \}$ , in which all $\{ I _ { s } \} ^ { k }$ and $I _ { q }$ contain objects from the same category. Then the training set and test set are represented by $\hat { D } _ { t r a i n } = \{ \{ I _ { s } \} ^ { k } , I _ { q } \} ^ { N _ { t r a i n } }$ and $D _ { t e s t } = \{ \{ I _ { s } \} ^ { k } , I _ { q } \} ^ { N _ { t e s t } }$ , where $N _ { t r a i n }$ and $N _ { t e s t }$ is the number of episodes for training and test set. During training, both support masks $M _ { s }$ and query masks $M _ { q }$ are available for training images, and only support masks are accessible during testing.
+
+# 3.2 Revisiting of Transformer
+
+Following the general form in [32], a transformer block is composed of alternating layers of multi-head attention (MHA) and multi-layer perceptron (MLP). LayerNorm (LN) [1] and residual connection [12] are applied at the end of each block. Specially, an attention layer is formulated as
+
+$$
+\mathrm { A t t e n } ( Q , K , V ) = \mathrm { s o f t m a x } ( \frac { Q K ^ { T } } { \sqrt { d } } ) V ,
+$$
+
+where $[ Q ; K ; V ] = [ W _ { q } Z _ { q } ; W _ { k } Z _ { k v } ; W _ { v } Z _ { k v } ] ,$ , in which $Z _ { q }$ is the input Query sequence, $Z _ { k v }$ is the input Key/Value sequence, $W _ { q } , W _ { k } , W _ { v } \in \mathbb R ^ { d \times d }$ denote the learnable parameters, $d$ is the hidden dimension of the input sequences and we assume all sequences have the same dimension $d$ by default. For each Query element, the attention layer computes its similarities with all Key elements. Then the computed similarities are normalized via softmax, which are used to multiply the Value elements to achieve the aggregated outputs. When $Z _ { q } = Z _ { k v }$ , it functions as self-attention mechanism.
+
+The multi-head attention layer is an extention of attention layer, which performs $h$ attention operations and concatenates consequences together. Specifically,
+
+$$
+\mathrm { M H A } ( Q , K , V ) = [ \mathrm { h e a d } _ { 1 } , . . . , \mathrm { h e a d } _ { \mathrm { h } } ] ,
+$$
+
+where $\mathrm { h e a d } _ { \mathrm { m } } = \mathrm { A t t e n } ( Q _ { m } , K _ { m } , V _ { m } )$ and the inputs $[ Q _ { m } , K _ { m } , V _ { m } ]$ are the $m ^ { t h }$ group from $[ Q , K , V ]$ with dimension $d / h$ .
+
+# 3.3 Cycle-Consistent Transformer
+
+Our framework is illustrated in Figure 3(a). Generally, an encoder of our Cycle-Consistent TRansformer (CyCTR) consists of a self-alignment transformer block for encoding the query features and a cross-alignment transformer block to enable the query features to attend to the informative support features. The whole CyCTR module stacks $L$ encoders.
+
+![](images/b54c33250bf14899c99b528404ecb8af57cca625e39b4ea0eb4ed2733577cfb0.jpg)  
+Figure 3: Framework of our proposed Cycle-Consistent TRansformer (CyCTR). Each encoder of CyCTR consists of two transformers blocks, i.e., the self-alignment block for utilizing global context within the query feature map and the cross-alignment block for aggregate information from support images. In the cross-alignment block, we introduce the multi-head cycle-consistent attention (shown on the right, with the number of heads $h = 1$ for simplicity). The attention operation is guided by the cycle-consistency among query and support features.
+
+Specifically, for the given query feature $X _ { q } \in \mathbb { R } ^ { H _ { q } \times W _ { q } \times d }$ and support feature $X _ { s } \in \mathbb R ^ { H _ { s } \times W _ { s } \times d }$ , we first flatten them into 1D sequences (with shape $H W \times d )$ as inputs for transformer, in which a token is represented by the feature $z \in \mathbb { R } ^ { d }$ at one pixel location. The self-alignment block only takes the flattened query feature as input. As context information of each pixel has been proved beneficial for segmentation [4, 47], we adopt the self-alignment block to pixel-wise features of query image to aggregate their global context information. We don’t pass support images through the self-alignment block, as we mainly focus on the segmentation performance of query images. Passing through the support images which don’t coordinate with the query mask may do harm to the self-alignment on query images.
+
+In contrast, the cross-alignment block performs attention between query and support pixel-wise features to aggregate relevant support features into query ones. It takes the flattened query feature and a subset of support feature (the sampling procedure is discussed latter) with size $N _ { s } \leq H _ { s } W _ { s }$ as Key/Value sequence $Z _ { k v }$ .
+
+With these two blocks, it is expected to better encoder the query features to facilitate the subsequent pixel-wise classification. When stacking $L$ encoders, the output of the previous encoder is fed into the self-alignment block. The outputs of self-alignment block and the sampled support features are then fed into the cross-alignment block.
+
+# 3.3.1 Cycle-Consistent Attention
+
+According to the aforementioned discussion, the pure pixel-level attention may be confused by excessive irrelevant support features. To alleviate this issue, as shown in Figure 3(b), a cycleconsistent attention operation is proposed. We first go through the proposed approach for 1-shot case for presentation simplicity and then discuss it in the multiple shot setting.
+
+Formally, an affinity map A = QKT√ , $\begin{array} { r } { A = \frac { Q K ^ { T } } { \sqrt { d } } , A \in \mathbb { R } ^ { H _ { q } W _ { q } \times N _ { s } } } \end{array}$ is first calculated to measure the correspondence between all query and support pixels. Then, for an arbitrary support pixel/token $j$ $( \bar { j } \in \{ 0 , 1 , . . . , N _ { s } - 1 \}$ , $N _ { s }$ is the number of support pixels), its most similar query pixel/token $i ^ { \star }$ is obtained by
+
+$$
+i ^ { \star } = \operatorname * { a r g m a x } _ { i } A _ { ( i , j ) } ,
+$$
+
+where $i \in \{ 0 , 1 , . . . , H _ { q } W _ { q } - 1 \}$ denotes the spatial index of query pixels. Since the query mask is not accessible, the label of query pixel $i ^ { \star }$ is unknown. However, we can in turn find its most similar support pixel $j ^ { \star }$ in the same way:
+
+$$
+j ^ { \star } = \operatorname * { a r g m a x } _ { j } A _ { ( i ^ { \star } , j ) } .
+$$
+
+Given the sampled support label $M _ { s } \in \mathbb { R } ^ { N _ { s } }$ , cycle-consistency is satisfied if $M _ { s ( j ) } = M _ { s ( j ^ { \star } ) }$ Previous work [16] attempts to encourage the feature similarity between cycle-consistent pixels to improve the model’s generalization ability within the same set of categories. However, in few-shot segmentation, the goal is to enable the model to fast adapt to novel categories rather than making the model fit better to training categories. Thus, we incorporate the cycle-consistency into the attention operation to encourage the cycle-consistent cross-attention. First, by traversing all support tokens, an additive bias $B \in \mathbb { R } ^ { \breve { N } _ { s } }$ is obtained by
+
+$$
+{ \cal B } _ { j } = \left\{ \begin{array} { c l } { { 0 , } } & { { \mathrm { i f } M _ { s ( j ) } = M _ { s ( j ^ { \star } ) } } } \\ { { - \infty , } } & { { \mathrm { i f } M _ { s ( j ) } \neq M _ { s ( j ^ { \star } ) } } } \end{array} \right. ,
+$$
+
+where $j \in \{ 0 , 1 , . . . , N _ { s } \}$ . Then, for a single query token $Z _ { q ( i ) } \in \mathbb { R } ^ { d }$ at location $i$ , the support information is aggregated by
+
+$$
+\mathrm { C y C A t t e n } ( Q _ { i } , K _ { i } , V _ { i } ) = \mathrm { s o f t m a x } ( A _ { ( i ) } + B ) V ,
+$$
+
+where $i \in \{ 0 , 1 , . . . , H _ { q } W _ { q } \}$ and $A$ is obtained by $\frac { Q K ^ { T } } { \sqrt { d } }$ . In the forward process, $B$ is element-wise added with the affinity $A _ { ( i ) }$ for $Z _ { q ( i ) }$ to aggregate support features. In this way, the attention weight for the cycle-inconsistent support features become zero, implying that these irrelevant information will not be considered. Besides, the cycle-consistent attention implicitly encourages the consistency between the most relevant query and support pixel-wise features through backpropagation. Note that our method aims at removing support pixels with certain inconsistency, rather than ensuring all support pixels to form cycle-consistency, which is impossible without knowing the query ground truth labels.
+
+When performing self-attention in the self-alignment block, there may also exist the same issue, i.e. the query token may attend to irrelevant or even harmful features (especially when background is complex). According to our cycle-consistent attention, each query token should receive information from more consistent pixels than aggregating from all pixels. Due to the lack of query mask $M _ { q }$ , it is impossible to establish the cycle-consistency among query pixels/tokens. Inspired by DeformableAttention [51], the consistent pixels can be obtained via a learnable way as $\Delta \bar { = } f ( Q \bar { + }$ Coord) and $A ^ { ' } = g ( Q + \mathrm { C o o r d } )$ , where $\Delta \in \mathbb { R } ^ { H _ { p } W _ { p } \times P }$ is the predicted consistent pixels, in which each element $\delta \in \mathbb { R } ^ { P }$ in $\Delta$ represents the relative offset from each pixel and $P$ represents the number of pixels to aggregate. And $\mathbf { \bar { \Psi } } A ^ { ' } \in \mathbb { R } ^ { H _ { q } W _ { q } \times P }$ is the attention weights. Coord $\in \mathbb { R } ^ { H _ { q } W _ { q } \times d }$ is the positional encoding [24] to make the prediction be aware of absolute position, and $f ( \cdot )$ and $g ( \cdot )$ are two fully connected layers that predict the offsets4 and attention weights. Therefore, the self-attention within the self-alignment transformer block is represented as
+
+$$
+\mathrm { P r e d A t t e n } ( Q _ { r } , V _ { r } ) = \sum _ { g } ^ { P } \mathrm { s o f t m a x } ( A ^ { ' } ) _ { ( r , g ) } V _ { r + \Delta _ { ( r , g ) } } ,
+$$
+
+where $r \in \{ 0 , 1 , . . . , H _ { q } W _ { q } \}$ is the index of the flattened query feature, both $Q$ and $V$ are obtained by multiplying the flattened query feature with the learnable parameter.
+
+Generally speaking, the cycle-consistent transformer effectively avoids the attention being biased by irrelevant features to benefit the training of few-shot segmentation.
+
+Mask-guided sparse sampling and $K$ -shot Setting: Our proposed cycle-consistency transformer can be easily extended to $K$ -shot setting where $K > 1$ . When multiple support feature maps are provided, all support features are flattened and concatenated together as input. As the attention is performed at the pixel-level, the computation load will be high if the number of support pixels/tokens is large, which is usually the case under $K$ -shot setting. In this work, we apply a simple mask-guided sampling strategy to reduce the computation complexity and make our method more scalable. Concretely, given the $k$ -shot support sequence $Z _ { s } \in \bar { \mathbb R } ^ { k H _ { s } \bar { W } _ { s } \times d }$ and the flattened support masks $M _ { s } \in \mathbb { R } ^ { k H _ { s } W _ { s } }$ , the support pixels/tokens are obtained by uniformly sampling $N _ { f g }$ tokens $\begin{array} { r } { ( N _ { f g } \ < = \ \frac { N _ { s } } { 2 } } \end{array}$ , where $N _ { s } \le k H _ { s } W _ { s } )$ from the foreground regions and $N _ { s } - N _ { f g }$ tokens from the background regions in all support images. With a proper $N _ { s }$ , the sampling operation reduces the computational complexity, and makes our algorithm more scalable with the increase of spatial size of support images. Additionally, this strategy helps balance the foreground-background ratio and also implicitly considers different sizes of various object regions in support images.
+
+Table 1: Comparison with other state-of-the-art methods for 1-shot and 5-shot segmentation on PASCAL- $. 5 ^ { i }$ using the mIoU $( \% )$ evaluation metric. Best results are shown in bold.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Backbone</td><td colspan="5">1-shot</td><td colspan="5">5-shot</td></tr><tr><td>50</td><td>5</td><td>52</td><td>5</td><td>Mean</td><td>50</td><td>5</td><td>5²</td><td>53</td><td>Mean</td></tr><tr><td>PANet [35]</td><td rowspan="3">Vgg-16</td><td>42.3</td><td>58.0</td><td>51.1</td><td>41.2</td><td>48.1</td><td>51.8</td><td>64.6</td><td>59.8</td><td>46.5</td><td>55.7</td></tr><tr><td>FWB [23]</td><td>47.0</td><td>59.6</td><td>52.6</td><td>48.3</td><td>51.9</td><td>50.9</td><td>62.9</td><td>56.5</td><td>50.1</td><td>55.1</td></tr><tr><td>SG-One [46]</td><td>40.2</td><td>58.4</td><td>48.4</td><td>38.4</td><td>46.3</td><td>41.9</td><td>58.6</td><td>48.6</td><td>39.4</td><td>47.1</td></tr><tr><td>RPMM [41]</td><td rowspan="4">Res-50</td><td>47.1</td><td>65.8</td><td>50.6</td><td>48.5</td><td>53.0</td><td>50.0</td><td>66.5</td><td>51.9</td><td>47.6</td><td>54.0</td></tr><tr><td>CANet [44]</td><td>52.5</td><td>65.9</td><td>51.3</td><td>51.9</td><td>55.4</td><td>55.5</td><td>67.8</td><td>51.9</td><td>53.2</td><td>57.1</td></tr><tr><td>PGNet [43]</td><td>56.0</td><td>66.9</td><td>50.6</td><td>50.4</td><td>56.0</td><td>57.7</td><td>68.7</td><td>52.9</td><td>54.6</td><td>58.5</td></tr><tr><td>RPMM [41]</td><td>55.2 47.8</td><td>66.9</td><td>52.6 53.8</td><td>50.7</td><td>56.3</td><td>56.3</td><td>67.3</td><td>54.5</td><td>51.0</td><td>57.3</td></tr><tr><td>PPNet [18]</td><td></td><td></td><td>58.8</td><td></td><td>45.6</td><td>51.5</td><td>58.4</td><td>67.8</td><td>64.9</td><td>56.7</td><td>62.0</td></tr><tr><td>PFENet [30]</td><td>Res-50</td><td>61.7</td><td>69.5</td><td>55.4</td><td>56.3</td><td>60.8</td><td>63.1</td><td>70.7</td><td>55.8</td><td>57.9</td><td>61.9</td></tr><tr><td>CyCTR (Ours)</td><td></td><td>65.7</td><td>71.0</td><td>59.5</td><td>59.7</td><td>64.0</td><td>69.3</td><td>73.5</td><td>63.8</td><td>63.5</td><td>67.5</td></tr><tr><td>FWB [23]</td><td>Res-101</td><td>51.3</td><td>64.5</td><td>56.7</td><td>52.2</td><td>56.2</td><td>54.9</td><td>67.4</td><td>62.2</td><td>55.3</td><td>59.9</td></tr><tr><td>DAN [34]</td><td></td><td>54.7</td><td>68.6</td><td>57.8</td><td>51.6</td><td>58.2</td><td>57.9</td><td>69.0</td><td>60.1</td><td>54.9</td><td>60.5</td></tr><tr><td>PFENet [30]</td><td>Res-101</td><td>60.5</td><td>69.4</td><td>54.4</td><td>55.9</td><td>60.1</td><td>62.8</td><td>70.4</td><td>54.9</td><td>57.6</td><td>61.4</td></tr><tr><td>CyCTR (Ours)</td><td></td><td>67.2</td><td>71.1</td><td>57.6</td><td>59.0</td><td>63.7</td><td>71.0</td><td>75.0</td><td>58.5</td><td>65.0</td><td>67.4</td></tr></table>
+
+# 3.4 Overall Framework
+
+Following previous works [30, 35, 44], both query and support images are first feed into a shared backbone (e.g., ResNet [12]) which is initialized with weights pretrained from ImageNet [25] to obtain general image features. Similar to [30], middle-level query features (the concatenation of query features from the $3 ^ { r d }$ and the $4 ^ { t h }$ blocks of ResNet) are processed by a $1 \times 1$ convolution to reduce the hidden dimension. The high-level query features (from the $5 ^ { t h }$ block) are used to generate a prior map (the prior map is generated by calculating the pixel-wise similarity between query and support features, details can be found in the supplementary materials) and then are concatenated with the middle-level query features. The average masked support feature is also concatenated to provide global support information. The concatenated features are processed by a $1 \times 1$ convolution. The output query features are then fed into our proposed CyCTR encoders. The output of CyCTR encoders is fed into a classifier to obtain the final segmentation results. The classifier consists of a $3 \times 3$ convolutional layer, a ReLU layer and a $1 \times 1$ convolutional layer. More details about our network structure can be found in the supplementary materials.
+
+# 4 Experiments
+
+# 4.1 Dataset and Evaluation Metric
+
+We conduct experiments on two commonly used few-shot segmentation datasets, Pascal- ${ \cdot } 5 ^ { i }$ [10] (which is combined with SBD [11] dataset) and COCO- $2 0 ^ { i }$ [17], to evaluate our method. For Pascal$5 ^ { i }$ , 20 classes are separated into 4 splits. For each split, 15 classes are used for training and 5 classes for test. At the test time, 1,000 pairs that belong to the testing classes are sampled from the validation set for evaluation. In $\mathrm { C O C O - 2 0 ^ { i } }$ , we follow the data split settings in FWB [23] to divide 80 classes evenly into 4 splits, 60 classes for training and test on 20 classes, and 5,000 validation pairs from the 20 classes are sampled for evaluation. Detailed data split settings can be found in the supplementary materials. Following common practice [30, 35, 46], the mean intersection over union (mIoU) is adopted as the evaluation metric, which is the averaged value of IoU of all test classes. We also report the foreground-background IoU (FB-IoU) for comparison.
+
+# 4.2 Implementation Details
+
+In our experiments, the training strategies follow the same setting in [30]: training for 50 epochs on $\mathrm { C O C O - 2 0 } ^ { i }$ and 200 epochs on Pascal- $5 ^ { i }$ . Images are resized and cropped to $4 7 3 \times 4 7 3$ for both datasets and we use random rotation from $- 1 0 ^ { \circ }$ to $1 0 ^ { \circ }$ as data augmentation. Besides, we use ImageNet [25] pretrained ResNet [12] as the backbone network and its parameters (including BatchNorms) are freezed. For the parameters except those in the transformer layers, we use the initial learning rate $2 . 5 \times 1 0 ^ { - 3 }$ , momentum 0.9, weight decay $1 \times 1 0 ^ { - 4 }$ and SGD optimizer with poly learning rate decay [4]. The mini batch size on each gpu is set to 4. Experiments are carried out on Tesla V100 GPUs. For Pascal- ${ \cdot } 5 ^ { i }$ , one model is trained on a single GPU, while for $\mathrm { C O C O - 2 0 ^ { i } }$ , one model is trained with 4 GPUs. We construct our baseline as follows: as stated in Section 3.4, the middle-level query features from backbone network are concatenated and merged with the global support feature and the prior map. This feature is processed by two residule blocks and input to the same classifier as our method. Dice loss [21] is used as the training objective. Besides, the middle-level query feature is averaged using the ground truth and concatenated with support feature to predict the support segmentation map, which produces an auxiliary loss for aligning features. The same settings are also used in our method except that we use our cycle-consistent transformer to process features rather than the residule blocks. For the proposed cycle-consistent transformer, we set the number of sampled support tokens $N _ { s }$ to 600 for 1-shot and $5 \times 6 0 0$ for 5-shot setting. The number of sampled tokens is obtained according to the averaged number of foreground pixels among Pascal- ${ \cdot } 5 ^ { i }$ training set. For the self-attention block, the number of points $P$ is set to 9. For other hyper-parameters in transformer blocks, we use $L = 2$ transformer encoders. We set the hidden dimension of MLP layer to $3 \times 2 5 6$ and that of input to 256. The number of heads for all attention layers is set to 8 for Pascal- ${ \cdot } 5 ^ { i }$ and 1 for $\mathrm { C O C O - 2 0 } ^ { \bar { i } }$ . Parameters in the transformer blocks are optimized with AdamW [20] optimizer following other transformer works [3, 8, 31], with learning rate $1 \times 1 0 ^ { - 4 }$ and weight decay $1 \times 1 0 ^ { - 2 }$ . Besides, we use Dropout with the probability 0.1 in all attention layers.
+
+Table 2: Comparison with other state-of-the-art methods for 1-shot and 5-shot segmentation on COCO- ${ \it 2 0 ^ { i } }$ using the mIoU $( \% )$ evaluation metric. Best results are shown in bold.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Backbone</td><td colspan="5">1-shot</td><td colspan="5">5-shot</td></tr><tr><td>200</td><td>201</td><td>20</td><td>20</td><td>Mean</td><td>200</td><td>201</td><td>20</td><td>20</td><td>Mean</td></tr><tr><td>FWB [23]</td><td>Res-101</td><td>19.9</td><td>18.0</td><td>21.0</td><td>28.9</td><td>21.2</td><td>19.1</td><td>21.5</td><td>23.9</td><td>30.1</td><td>23.7</td></tr><tr><td>PPNet[18]</td><td>Res-50</td><td>28.1</td><td>30.8</td><td>29.5</td><td>27.7</td><td>29.0</td><td>39.0</td><td>40.8</td><td>37.1</td><td>37.3</td><td>38.5</td></tr><tr><td>RPMM [41]</td><td>Res-50</td><td>29.5</td><td>36.8</td><td>29.0</td><td>27.0</td><td>30.6</td><td>33.8</td><td>42.0</td><td>33.0</td><td>33.3</td><td>35.5</td></tr><tr><td>PFENet [30]</td><td>Res-101</td><td>34.3</td><td>33.0</td><td>32.3</td><td>30.1</td><td>32.4</td><td>38.5</td><td>38.6</td><td>38.2</td><td>34.3</td><td>37.4</td></tr><tr><td>CyCTR (Ours)</td><td>Res-50</td><td>38.9</td><td>43.0</td><td>39.6</td><td>39.8</td><td>40.3</td><td>41.1</td><td>48.9</td><td>45.2</td><td>47.0</td><td>45.6</td></tr></table>
+
+# 4.3 Comparisons with State-of-the-Art Methods
+
+In Table 1 and Table 2, we compare our method with other state-of-the-art few-shot segmentation approaches on Pascal- ${ \cdot } 5 ^ { i }$ and $\mathrm { C O C O - 2 0 ^ { i } }$ respectively. It can be seen that our approach achieves new state-of-the-art performance on both Pascal- $5 ^ { i }$
+
+and $\mathrm { C O C O - 2 0 ^ { i } }$ . Specifically, on Pascal- $5 ^ { i }$ , to make fair comparisons with other methods, we report results with both ResNet-50 and ResNet101. Our CyCTR achieves $6 4 . 0 \%$ mIoU with ResNet-50 backbone and $6 3 . 7 \%$ mIoU with ResNet-101 backbone for 1-shot segmentation, significantly outperforming previous state-ofthe-art results by $3 . 2 \%$ and $3 . 6 \%$ , respectively. For 5-shot segmentation, our CyCTR can even surpass state-of-the art methods by $5 . 6 \%$ and $6 . 0 \%$ mIoU when using ResNet-50 and ResNet
+
+Table 3: Comparison with other methods using FB-IoU $( \% )$ on Pascal- ${ \cdot } 5 ^ { i }$ for 1-shot and 5-shot segmentation.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Backbone</td><td>FB-IoU (%)</td></tr><tr><td>1-shot 5-shot</td></tr><tr><td>A-MCG [13]</td><td>Res-101</td><td>61.2 62.2</td></tr><tr><td>DAN [34]</td><td>Res-101</td><td>71.9 72.3</td></tr><tr><td>PFENet [30]</td><td>Res-101</td><td>72.9 73.5</td></tr><tr><td>CyCTR (Ours)</td><td>Res-101</td><td>73.0 75.4</td></tr></table>
+
+101 backbones respectively. For $\mathrm { C O C O - 2 0 ^ { i } }$ results in Table 2, our method also outperforms other methods by a large margin due to the capability of the transformer to fit more complex data. Besides, Table 3 shows the comparison using FB-IoU on PASCAL- ${ \cdot } 5 ^ { i }$ for 1-shot and 5-shot segmentation, our method also obtains the state-of-the-art performance.
+
+# 4.4 Ablation Studies
+
+To provide a deeper understanding of our proposed method, we show ablation studies in this section. The experiments are performed on Pascal- $5 ^ { i }$ 1-shot setting with ResNet-50 as the backbone network, and results are reported in terms of mIoU.
+
+Table 4: Ablation studies that validate the effectiveness of each component in our Cycle-Consistent TRansformer. The first result is obtained by our baseline (see Section 4.2 for details).   
+
+<table><tr><td>self-alignment</td><td>cross-alignment</td><td>CyCTR (pred)</td><td>CyCTR (fg. only)</td><td>CyCTR</td><td>mIoU (%)</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>59.3 62.5</td></tr><tr><td>&gt;&gt;&gt;</td><td></td><td></td><td></td><td></td><td>62.9</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>62.6</td></tr><tr><td></td><td>&gt;&gt;&gt;</td><td>√</td><td>厂</td><td></td><td>63.0</td></tr><tr><td>广</td><td>√</td><td></td><td></td><td>√</td><td>63.5</td></tr></table>
+
+# 4.4.1 Component-Wise Ablations
+
+We perform ablation studies regarding each component of our CyCTR in Table 4. The first line is the result of our baseline, where we use two residual blocks to merge features as stated in Section 4.2. For all ablations in Table 4, the hidden dimension is set to 128 and two transformer encoders are used. The mIoU results are averaged over four splits. Firstly, we only use the self-alignment block that only encodes query features. The support information in this case comes from the concatenated global support feature and the prior map used in [44]. It can already bring decent results, showing that the transformer encoder is effective for modeling context for few-shot segmentation. Then, we utilize the cross-alignment block but only with the vanilla attention operation in Equation 1. The mIoU increases by $0 . 4 \%$ , indicating that pixel-level features from support can provide additional performance gain. By using our proposed cycle-consistent attention module, the performance can be further improved by a large margin, i.e. $0 . 6 \%$ mIoU compared to the vanilla attention. This result demonstrates our cycle-consistent attention’s capability to suppress possible harmful information from support. Besides, we assume some background support features may also benefit the query segmentation and therefore use the cycle-consistent transformer to aggregate pixel-level information from background support features as well. Comparing the last two lines in Table 4, we show that our way of utilizing beneficial background pixel-level support information brings $0 . 5 \%$ mIoU improvement, validating our assumption and the effectiveness of our proposed cycle-consistent attention operation.
+
+Besides, one may be curious about whether the noise can also be removed by predicting the aggregation position like the way in Equation 6 for aggregating support features to query. Therefore, we use predicted aggregation instead of the cycle-consistent attention in the cross-alignment block, as denoted by $C y C T R ( p r e d )$ in Table 4. It does benefit the few-shot segmentation by aggregating useful information from support but is $0 . 9 \%$ worse than the proposed cycle-consistent attention. The reason lies in the dramatically changing support images under few-shot segmentation testing. The cycle-consistency is better than the learnable way as it can globally consider the varying conditional information from both query and support.
+
+# 4.4.2 Effect of Model Capacity
+
+We can stack more encoders or increase the hidden dimension of encoders to increase its capacity and validate the effectiveness of our CyCTR. The results with different numbers of encoders (denoted as $L$ ) or hidden dimensions (denoted as $d$ ) are shown in Table 5a and 5b. While increasing $L$ or $d$ within a certain range, CyCTR achieves better results. We chose $L = 2$ as our default choice for accuracy-efficiency trade-off.
+
+Table 5: Effect of varying (a) number of encoders $L$ and (b) hidden dimensions $d$ . When varying $L$ , $d$ is fixed to 128; while varying $d , L$ is fixed to 2.   
+
+<table><tr><td>#Encoder</td><td>mIoU (%)</td><td>#Dim</td><td>mIoU (%)</td></tr><tr><td>1</td><td>62.4</td><td>128</td><td>63.5</td></tr><tr><td>2</td><td>63.5</td><td>256</td><td>64.0</td></tr><tr><td>3</td><td>63.7</td><td>384</td><td>63.9</td></tr><tr><td colspan="2">(a)</td><td colspan="2">(b)</td></tr></table>
+
+# 4.5 Qualitative results
+
+In Figure 4, we show some qualitative results generated by our model on Pascal- $5 ^ { i }$ . Our cycleconsistent attention can improve the segmentation quality by suppressing possible harmful information from support. For instance, without cycle-consistency, the model misclassifies trousers as “cow” in the first row, baby’s hair as “cat” in the second row, and a fraction of mountain as “car” in the third row, while our model rectifies these part as background. However, in the first row, our CyCTR still segments part of the trousers as "cow" and the right boundary of the segmentation mask is slightly worse than the model without cycle-consistency. The reason comes from the extreme differences between query and support, i.e. the support image shows a "cattle" but the query image contains a milk cow. The cycle-consistency may over-suppress the positive region in support images. Solving such issue may be a potential direction to investigate to improve our method further.
+
+![](images/13eb69bca8df05815dd7d37e102ac9b3e39ea306bd9e3859ce1a7c776634e965.jpg)  
+Figure 4: Qualitative results on Pascal- ${ \cdot } 5 ^ { i }$ . From left to right, each column shows the examples of: Support image with mask region in red; Query image with ground truth mask region in blue; Result produced by the model without cycle-consistency in CyCTR; Result produced by our method.
+
+# 5 Conclusion
+
+In this paper, we design a CyCTR module to deal with the few-shot segmentation problem. Different from previous practices that either adopt semantic-level prototype(s) from support images or only use foreground support features to encode query features, our CyCTR utilizes all pixel-level support features and can effectively eliminate aggregating confusing and harmful support features with the proposed novel cycle-consistency attention. We conduct extensive experiments on two popular benchmarks, and our CyCTR outperforms previous state-of-the-art methods by a significant margin. We hope this work can motivate researchers to utilize pixel-level support features to design more effective algorithms to advance the few-shot segmentation research.
+
+# References
+
+[1] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   
+[2] Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   
+[3] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pages 213–229. Springer, 2020.   
+[4] Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. IEEE transactions on pattern analysis and machine intelligence, 40(4):834–848, 2017.   
+[5] Rewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   
+[6] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   
+[7] Nanqing Dong and Eric P Xing. Few-shot semantic segmentation with prototype learning. In BMVC, volume 3-4, 2018.   
+[8] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+[9] Debidatta Dwibedi, Yusuf Aytar, Jonathan Tompson, Pierre Sermanet, and Andrew Zisserman. Temporal cycle-consistency learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1801–1810, 2019.   
+[10] Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. International journal of computer vision, 88(2):303–338, 2010.   
+[11] Bharath Hariharan, Pablo Arbeláez, Ross Girshick, and Jitendra Malik. Simultaneous detection and segmentation. In European Conference on Computer Vision, pages 297–312. Springer, 2014.   
+[12] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), pages 770–778, 2016.   
+[13] Tao Hu, Pengwan Yang, Chiliang Zhang, Gang Yu, Yadong Mu, and Cees GM Snoek. Attentionbased multi-context guiding for few-shot semantic segmentation. In Association for the Advancement of Artificial Intelligence (AAAI), volume 33, pages pp. 8441–8448, 2019.   
+[14] Zilong Huang, Xinggang Wang, Lichao Huang, Chang Huang, Yunchao Wei, and Wenyu Liu. Ccnet: Criss-cross attention for semantic segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 603–612, 2019.   
+[15] Zilong Huang, Xinggang Wang, Jiasi Wang, Wenyu Liu, and Jingdong Wang. Weaklysupervised semantic segmentation network with deep seeded region growing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7014–7023, 2018.   
+[16] Guoliang Kang, Yunchao Wei, Yi Yang, Yueting Zhuang, and Alexander G Hauptmann. Pixellevel cycle association: A new perspective for domain adaptive semantic segmentation. In NeurIPS, 2020.   
+[17] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision (ECCV), 2014.   
+[18] Yongfei Liu, Xiangyi Zhang, Songyang Zhang, and Xuming He. Part-aware prototype network for few-shot semantic segmentation. In European Conference on Computer Vision, pages 142–158. Springer, 2020.   
+[19] Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 3431–3440, 2015.   
+[20] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.   
+[21] Fausto Milletari, Nassir Navab, and Seyed-Ahmad Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In 2016 fourth international conference on 3D vision (3DV), pages 565–571. IEEE, 2016.   
+[22] Juhong Min, Dahyun Kang, and Minsu Cho. Hypercorrelation squeeze for few-shot segmentation. arXiv preprint arXiv:2104.01538, 2021.   
+[23] Khoi Nguyen and Sinisa Todorovic. Feature weighting and boosting for few-shot segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 622–631, 2019.   
+[24] Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image transformer. In International Conference on Machine Learning, pages 4055–4064. PMLR, 2018.   
+[25] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.   
+[26] Amirreza Shaban, Shray Bansal, Zhen Liu, Irfan Essa, and Byron Boots. One-shot learning for semantic segmentation. In British Machine Vision Conference (BMVC), 2018.   
+[27] Han Shi, Jiahui Gao, Xiaozhe Ren, Hang Xu, Xiaodan Liang, Zhenguo Li, and James T Kwok. Sparsebert: Rethinking the importance analysis in self-attention. arXiv preprint arXiv:2102.12871, 2021.   
+[28] Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in neural information processing systems (NeurIPS), 2017.   
+[29] Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1199–1208, 2018.   
+[30] Z Tian, H Zhao, M Shu, Z Yang, R Li, and J Jia. Prior guided feature enrichment network for few-shot segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.   
+[31] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   
+[32] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 6000–6010, 2017.   
+[33] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   
+[34] Haochen Wang, Xudong Zhang, Yutao Hu, Yandan Yang, Xianbin Cao, and Xiantong Zhen. Few-shot semantic segmentation with democratic attention networks. In European Conference on Computer Vision (ECCV), 2020.   
+[35] Kaixin Wang, Jun Hao Liew, Yingtian Zou, Daquan Zhou, and Jiashi Feng. Panet: Few-shot image semantic segmentation with prototype alignment. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9197–9206, 2019.   
+[36] Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 7794–7803, 2018.   
+[37] Xiaolong Wang, Allan Jabri, and Alexei A Efros. Learning correspondence from the cycleconsistency of time. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2566–2576, 2019.   
+[38] Yunchao Wei, Jiashi Feng, Xiaodan Liang, Ming-Ming Cheng, Yao Zhao, and Shuicheng Yan. Object region mining with adversarial erasing: A simple classification to semantic segmentation approach. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1568–1576, 2017.   
+[39] Yunchao Wei, Huaxin Xiao, Honghui Shi, Zequn Jie, Jiashi Feng, and Thomas S Huang. Revisiting dilated convolution: A simple approach for weakly-and semi-supervised semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7268–7277, 2018.   
+[40] Yangxin Wu, Gengwei Zhang, Yiming Gao, Xiajun Deng, Ke Gong, Xiaodan Liang, and Liang Lin. Bidirectional graph reasoning network for panoptic segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9080–9089, 2020.   
+[41] Boyu Yang, Chang Liu, Bohao Li, Jianbin Jiao, and Qixiang Ye. Prototype mixture models for few-shot semantic segmentation. In European Conference on Computer Vision, pages 763–778. Springer, 2020.   
+[42] Lihe Yang, Wei Zhuo, Lei Qi, Yinghuan Shi, and Yang Gao. Mining latent classes for few-shot segmentation. arXiv preprint arXiv:2103.15402, 2021.   
+[43] Chi Zhang, Guosheng Lin, Fayao Liu, Jiushuang Guo, Qingyao Wu, and Rui Yao. Pyramid graph networks with connection attentions for region-based one-shot semantic segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9587–9595, 2019.   
+[44] Chi Zhang, Guosheng Lin, Fayao Liu, Rui Yao, and Chunhua Shen. Canet: Class-agnostic segmentation networks with iterative refinement and attentive few-shot learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5217–5226, 2019.   
+[45] Shiyin Zhang, Jun Hao Liew, Yunchao Wei, Shikui Wei, and Yao Zhao. Interactive object segmentation with inside-outside guidance. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12234–12244, 2020.   
+[46] Xiaolin Zhang, Yunchao Wei, Yi Yang, and Thomas S Huang. Sg-one: Similarity guidance network for one-shot semantic segmentation. IEEE Transactions on Cybernetics, 50(9):3855– 3865, 2020.   
+[47] Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), 2017.   
+[48] Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Scene parsing through ade20k dataset. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 633–641, 2017.   
+[49] Tinghui Zhou, Philipp Krahenbuhl, Mathieu Aubry, Qixing Huang, and Alexei A Efros. Learning dense correspondence via 3d-guided cycle consistency. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 117–126, 2016.   
+[50] Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE international conference on computer vision, pages 2223–2232, 2017.   
+[51] Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, and Jifeng Dai. Deformable detr: Deformable transformers for end-to-end object detection. arXiv preprint arXiv:2010.04159, 2020.

parse/train/LWH-C1HoQG_/LWH-C1HoQG__content_list.json

@@ -0,0 +1,1059 @@
+[
+    {
+        "type": "text",
+        "text": "Few-Shot Segmentation via Cycle-Consistent Transformer ",
+        "text_level": 1,
+        "bbox": [
+            228,
+            122,
+            769,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gengwei Zhang1,2∗, Guoliang Kang3, Yi Yang4, Yunchao Wei5,6† 1 Baidu Research   \n2 ReLER, Centre for Artificial Intelligence, University of Technology Sydney 3 University of Texas, Austin   \n4 CCAI, College of Computer Science and Technology, Zhejiang University 5 Institute of Information Science, Beijing Jiaotong University 6 Beijing Key Laboratory of Advanced Information Science and Network {zgwdavid, kgl.prml, wychao1987, yee.i.yang} $@$ gmail.com ",
+        "bbox": [
+            245,
+            219,
+            751,
+            337
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            372,
+            535,
+            388
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Few-shot segmentation aims to train a segmentation model that can fast adapt to novel classes with few exemplars. The conventional training paradigm is to learn to make predictions on query images conditioned on the features from support images. Previous methods only utilized the semantic-level prototypes of support images as the conditional information. These methods cannot utilize all pixel-wise support information for the query predictions, which is however critical for the segmentation task. In this paper, we focus on utilizing pixel-wise relationships between support and query images to facilitate the few-shot segmentation task. We design a novel Cycle-Consistent TRansformer (CyCTR) module to aggregate pixel-wise support features into query ones. CyCTR performs cross-attention between features from different images, i.e. support and query images. We observe that there may exist unexpected irrelevant pixel-level support features. Directly performing cross-attention may aggregate these features from support to query and bias the query features. Thus, we propose using a novel cycle-consistent attention mechanism to filter out possible harmful support features and encourage query features to attend to the most informative pixels from support images. Experiments on all few-shot segmentation benchmarks demonstrate that our proposed CyCTR leads to remarkable improvement compared to previous state-of-the-art methods. Specifically, on Pascal- ${ \\mathrm { ~ \\bar { \\cdot } ~ } } 5 ^ { i }$ and $\\mathrm { C O C O - } \\bar { 2 } 0 ^ { i }$ datasets, we achieve $6 7 . 5 \\%$ and $4 5 . 6 \\%$ mIoU for 5-shot segmentation, outperforming previous state-of-the-art method by $5 . 6 \\%$ and $7 . 1 \\%$ respectively. ",
+        "bbox": [
+            233,
+            405,
+            766,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            310,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent years have witnessed great progress in semantic segmentation [19, 4, 47]. The success can be largely attributed to large amounts of annotated data [48, 17]. However, labeling dense segmentation masks are very time-consuming [45]. Semi-supervised segmentation [15, 39, 38] has been broadly explored to alleviate this problem, which assumes a large amount of unlabeled data is accessible. However, semi-supervised approaches may fail to generalize to novel classes with very few exemplars. In the extreme low data regime, few-shot segmentation [26, 35] is introduced to train a segmentation model that can quickly adapt to novel categories. ",
+        "bbox": [
+            174,
+            758,
+            826,
+            856
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3515756eb6376bef3d1c8d8fbc89702c1c6040d2db9781f39f3b540cf852b6b7.jpg",
+        "image_caption": [
+            "Figure 1: Different learning frameworks for few-shot segmentation, from the perspective of ways to utilize support information. (a) Class-wise mean pooling based method. (b) Clustering based method. (c) Foreground pixel attention method. (d) Our Cycle-Consistent TRansformer (CyCTR) framework that enables all beneficial support pixel-level features (foreground and background) to be considered. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            90,
+            821,
+            175
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most few-shot segmentation methods follow a learning-to-learn paradigm where predictions of query images are made conditioned on the features and annotations of support images. The key to the success of this training paradigm lies in how to effectively utilize the information provided by support images. Previous approaches extract semantic-level prototypes from support features and follow a metric learning [29, 7, 35] pipeline extending from PrototypicalNet [28]. According to the granularity of utilizing support features, these methods can be categorized into two groups, as illustrated in Figure 1: 1) Class-wise mean pooling [35, 46, 44] (Figure 1(a)). Support features within regions of different categories are averaged to serve as prototypes to facilitate the classification of query pixels. 2) Clustering [18, 41] (Figure 1(b)). Recent works attempt to generate multiple prototypes via EM algorithm or K-means clustering [41, 18], in order to extract more abundant information from support images. These prototype-based methods need to “compress\" support information into different prototypes (i.e. class-wise or cluster-wise), which may lead to various degrees of loss of beneficial support information and thus harm segmentation on query image. Rather than using prototypes to abstract the support information, [43, 34] (Figure 1(c)) propose to employ the attention mechanism to extract information from support foreground pixels for segmenting query. However, such methods ignore all the background support pixels that can be beneficial for segmenting query image, and incorrectly consider partial foreground support pixels that are quite different from the query ones, leading to sub-optimal results. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on equipping each query pixel with relevant information from support images to facilitate the query pixel classification. Inspired by the transformer architecture [32] which performs feature aggregation through attention, we design a novel Cycle-Consistent Transformer (CyCTR) module (Figure 1(d)) to aggregate pixel-wise support features into query ones. Specifically, our CyCTR consists of two types of transformer blocks: the self-alignment block and the cross-alignment block. The selfalignment block is employed to encode the query image features by aggregating its relevant context information, while the cross-alignment aims to aggregate the pixel-wise features of support images into the pixel-wise features of query image. Different from self-alignment where Query3, Key and Value come from the same ",
+        "bbox": [
+            174,
+            522,
+            485,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4176acdf25fe22f9afc4fcfddcb55cb3d6c27e425d48ce4e279f955abbe2f6b4.jpg",
+        "image_caption": [
+            "Figure 2: The motivation of our proposed method. Many pixel-level support features are quite different from the query ones, and thus may confuse the attention. We incorporate cycle-consistency into attention to filter such confusing support features. Note that the confusing support features may come from foreground and background. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            527,
+            820,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "embedding, cross-alignment takes features from query images as Query, and those from support images as Key and Value. In this way, CyCTR provides abundant pixel-wise support information for pixel-wise features of query images to make predictions. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we observe that due to the differences between support and query images, e.g., scale, color and scene, only a small proportion of support pixels can be beneficial for the segmentation of query image. In other words, in the support image, some pixel-level information may confuse the attention in the transformer. Figure 2 provides a visual example of a support-query pair together with the label masks. The confusing support pixels may come from both foreground pixels and background pixels. For instance, point $p _ { 1 }$ in the support image located in the plane afar, which is indicated as foreground by the support mask. However, the nearest point $p _ { 2 }$ in the query image (i.e. $p _ { 2 }$ has the largest feature similarity with $p _ { 1 }$ ) belongs to a different category, i.e. background. That means, there exists no query pixel which has both high similarity and the same semantic label with $p _ { 1 }$ . Thus, $p _ { 1 }$ is likely to be harmful for segmenting \"plane\" and should be ignored when performing the attention. To overcome this issue, in CyCTR, we propose to equip the cross-alignment block with a novel cycle-consistent attention operation. Specifically, as shown in Figure 2, starting from the feature of one support pixel, we find its nearest neighbor in the query features. In turn, this nearest neighbor finds the most similar support feature. If the starting and the end support features come from the same category, a cycle-consistency relationship is established. We incorporate such an operation into attention to force query features only attend to cycle-consistent support features to extract information. In this way, the support pixels that are far away from query ones are not considered. Meanwhile, cycle-consistent attention enables us to more safely utilize the information from background support pixels, without introducing much bias into the query features. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            297
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a nutshell, our contributions are summarized as follows: (1) We tackle few-shot segmentation from the perspective of providing each query pixel with relevant information from support images through pixel-wise alignment. (2) We propose a novel Cycle-Consistent TRansformer (CyCTR) to aggregate the pixel-wise support features into the query ones. In CyCTR, we observe that many support features may confuse the attention and bias pixel-level feature aggregation, and propose incorporating cycle-consistent operation into the attention to deal with this issue. (3) Our CyCTR achieves state-ofthe-art results on two few-shot segmentation benchmarks, i.e., Pascal- $5 ^ { i }$ and COCO- $2 0 ^ { i }$ . Extensive experiments validate the effectiveness of each component in our CyCTR. ",
+        "bbox": [
+            174,
+            304,
+            825,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            321,
+            457
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Few-Shot Segmentation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            377,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Few-shot segmentation [26] is established to perform segmentation with very few exemplars. Recent approaches formulate few-shot segmentation from the view of metric learning [29, 7, 35]. For instance, [7] first extends PrototypicalNet [28] to perform few-shot segmentation. PANet [35] simplifies the framework with an efficient prototype learning framework. SG-One [46] leverage the cosine similarity map between the single support prototype and query features to guide the prediction. CANet [44] replaces the cosine similarity with an additive alignment module and iteratively refines the network output. PFENet [30] further designs an effective feature pyramid module and leverages a prior map to achieve better segmentation performance. Recently, [41, 18, 43] point out that only a single support prototype is insufficient to represent a given category. Therefore, they attempt to obtain multiple prototypes via EM algorithm to represent the support objects and the prototypes are compared with query image based on cosine similarity [18, 41]. Besides, [43, 34] attempt to use graph attention networks [33, 40] to utilize all foreground support pixel features. However, they ignore all pixels in the background region by default. Besides, due to the large difference between support and query images, not all support pixels will benefit final query segmentation. Recently, some concurrent works propose to learn dense matching through Hypercorrelation Squeeze Networks [22] or mining latent classes [42] from the background region. Our work aims at mining information from the whole support image, but exploring to use the transformer architecture and from a different perspective, i.e., reducing the noise in the support pixel-level features. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Transformer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            772,
+            300,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformer and self-attention were firstly introduced in the fields of machine translation and natural language processing [6, 32], and are receiving increasing interests recently in the computer vision area. Previous works utilize self-attention as additional module on top of existing convolutional networks, e.g., Nonlocal [36] and CCNet [14]. ViT [8] and its following work [31] demonstrate the pure transformer architecture can achieve state-of-the-art for image recognition. On the other hand, DETR [3] builds up an end-to-end framework with a transformer encoder-decoder on top of backbone networks for object detection. And its deformable vairents [51] improves the performance and training efficiency. Besides, in natural language processing, a few works [2, 5, 27] have been introduced for long documents processing with sparse transformers. In these works, each Query token only attends to a pre-defined subset of Key positions. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Cycle-consistency Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            405,
+            150
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our work is partially inspired by cycle-consistency learning [50, 9] that is explored in various computer vision areas. For instance, in image translation, CycleGAN [50] uses cycle-consistency to align image pairs. It is also effective in learning 3D correspondence [49], consistency between video frames [37] and association between different domains [16]. These works typically constructs cycle-consistency loss between aligned targets (e.g., images). However, the simple training loss cannot be directly applied to few-shot segmentation because the test categories are unseen from the training process and no finetuning is involved during testing. In this work, we incorporate the idea of cycle-consistency into transformer to eliminate the negative effect of confusing or irrelevant support pixels. ",
+        "bbox": [
+            173,
+            160,
+            825,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            313,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Problem Setting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            335,
+            326,
+            351
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Few-shot segmentation aims at training a segmentation model that can segment novel objects with very few annotated samples. Specifically, given dataset $D _ { t r a i n }$ and $D _ { t e s t }$ with category set $C _ { t r a i n }$ and $C _ { t e s t }$ respectively, where $C _ { t r a i n } \\cap C _ { t e s t } = { \\emptyset }$ , the model trained on $D _ { t r a i n }$ is directly used to test on $D _ { t e s t }$ . In line with previous works [30, 35, 44], episode training is adopted in this work for few-shot segmentation. Each episode is composed of $k$ support images $I _ { s }$ and a query image $I _ { q }$ to form a $k$ -shot episode $\\{ \\{ I _ { s } \\} ^ { k } , I _ { q } \\}$ , in which all $\\{ I _ { s } \\} ^ { k }$ and $I _ { q }$ contain objects from the same category. Then the training set and test set are represented by $\\hat { D } _ { t r a i n } = \\{ \\{ I _ { s } \\} ^ { k } , I _ { q } \\} ^ { N _ { t r a i n } }$ and $D _ { t e s t } = \\{ \\{ I _ { s } \\} ^ { k } , I _ { q } \\} ^ { N _ { t e s t } }$ , where $N _ { t r a i n }$ and $N _ { t e s t }$ is the number of episodes for training and test set. During training, both support masks $M _ { s }$ and query masks $M _ { q }$ are available for training images, and only support masks are accessible during testing. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Revisiting of Transformer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            518,
+            393,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following the general form in [32], a transformer block is composed of alternating layers of multi-head attention (MHA) and multi-layer perceptron (MLP). LayerNorm (LN) [1] and residual connection [12] are applied at the end of each block. Specially, an attention layer is formulated as ",
+        "bbox": [
+            174,
+            544,
+            825,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/10f52559f3ddc3e7c45ca9a0eff0c517e84b49cc5da29bd326ebd9d1d4ffe412.jpg",
+        "text": "$$\n\\mathrm { A t t e n } ( Q , K , V ) = \\mathrm { s o f t m a x } ( \\frac { Q K ^ { T } } { \\sqrt { d } } ) V ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            590,
+            629,
+            626
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $[ Q ; K ; V ] = [ W _ { q } Z _ { q } ; W _ { k } Z _ { k v } ; W _ { v } Z _ { k v } ] ,$ , in which $Z _ { q }$ is the input Query sequence, $Z _ { k v }$ is the input Key/Value sequence, $W _ { q } , W _ { k } , W _ { v } \\in \\mathbb R ^ { d \\times d }$ denote the learnable parameters, $d$ is the hidden dimension of the input sequences and we assume all sequences have the same dimension $d$ by default. For each Query element, the attention layer computes its similarities with all Key elements. Then the computed similarities are normalized via softmax, which are used to multiply the Value elements to achieve the aggregated outputs. When $Z _ { q } = Z _ { k v }$ , it functions as self-attention mechanism. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            717
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The multi-head attention layer is an extention of attention layer, which performs $h$ attention operations and concatenates consequences together. Specifically, ",
+        "bbox": [
+            173,
+            722,
+            825,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cabddda89e62a029943dc08c4fb51e180fe21d0d7110d603b693efd10586a99e.jpg",
+        "text": "$$\n\\mathrm { M H A } ( Q , K , V ) = [ \\mathrm { h e a d } _ { 1 } , . . . , \\mathrm { h e a d } _ { \\mathrm { h } } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            756,
+            625,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { h e a d } _ { \\mathrm { m } } = \\mathrm { A t t e n } ( Q _ { m } , K _ { m } , V _ { m } )$ and the inputs $[ Q _ { m } , K _ { m } , V _ { m } ]$ are the $m ^ { t h }$ group from $[ Q , K , V ]$ with dimension $d / h$ . ",
+        "bbox": [
+            173,
+            785,
+            825,
+            814
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Cycle-Consistent Transformer ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            830,
+            423,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our framework is illustrated in Figure 3(a). Generally, an encoder of our Cycle-Consistent TRansformer (CyCTR) consists of a self-alignment transformer block for encoding the query features and a cross-alignment transformer block to enable the query features to attend to the informative support features. The whole CyCTR module stacks $L$ encoders. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b54c33250bf14899c99b528404ecb8af57cca625e39b4ea0eb4ed2733577cfb0.jpg",
+        "image_caption": [
+            "Figure 3: Framework of our proposed Cycle-Consistent TRansformer (CyCTR). Each encoder of CyCTR consists of two transformers blocks, i.e., the self-alignment block for utilizing global context within the query feature map and the cross-alignment block for aggregate information from support images. In the cross-alignment block, we introduce the multi-head cycle-consistent attention (shown on the right, with the number of heads $h = 1$ for simplicity). The attention operation is guided by the cycle-consistency among query and support features. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            823,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, for the given query feature $X _ { q } \\in \\mathbb { R } ^ { H _ { q } \\times W _ { q } \\times d }$ and support feature $X _ { s } \\in \\mathbb R ^ { H _ { s } \\times W _ { s } \\times d }$ , we first flatten them into 1D sequences (with shape $H W \\times d )$ as inputs for transformer, in which a token is represented by the feature $z \\in \\mathbb { R } ^ { d }$ at one pixel location. The self-alignment block only takes the flattened query feature as input. As context information of each pixel has been proved beneficial for segmentation [4, 47], we adopt the self-alignment block to pixel-wise features of query image to aggregate their global context information. We don’t pass support images through the self-alignment block, as we mainly focus on the segmentation performance of query images. Passing through the support images which don’t coordinate with the query mask may do harm to the self-alignment on query images. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In contrast, the cross-alignment block performs attention between query and support pixel-wise features to aggregate relevant support features into query ones. It takes the flattened query feature and a subset of support feature (the sampling procedure is discussed latter) with size $N _ { s } \\leq H _ { s } W _ { s }$ as Key/Value sequence $Z _ { k v }$ . ",
+        "bbox": [
+            174,
+            512,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With these two blocks, it is expected to better encoder the query features to facilitate the subsequent pixel-wise classification. When stacking $L$ encoders, the output of the previous encoder is fed into the self-alignment block. The outputs of self-alignment block and the sampled support features are then fed into the cross-alignment block. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 Cycle-Consistent Attention ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            413,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "According to the aforementioned discussion, the pure pixel-level attention may be confused by excessive irrelevant support features. To alleviate this issue, as shown in Figure 3(b), a cycleconsistent attention operation is proposed. We first go through the proposed approach for 1-shot case for presentation simplicity and then discuss it in the multiple shot setting. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formally, an affinity map A = QKT√ , $\\begin{array} { r } { A = \\frac { Q K ^ { T } } { \\sqrt { d } } , A \\in \\mathbb { R } ^ { H _ { q } W _ { q } \\times N _ { s } } } \\end{array}$ is first calculated to measure the correspondence between all query and support pixels. Then, for an arbitrary support pixel/token $j$ $( \\bar { j } \\in \\{ 0 , 1 , . . . , N _ { s } - 1 \\}$ , $N _ { s }$ is the number of support pixels), its most similar query pixel/token $i ^ { \\star }$ is obtained by ",
+        "bbox": [
+            173,
+            729,
+            825,
+            794
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3ec0e9d9cbfaca536eb21da3c942a30ba6621c78c75f0780bb9215bc39c1526.jpg",
+        "text": "$$\ni ^ { \\star } = \\operatorname * { a r g m a x } _ { i } A _ { ( i , j ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            800,
+            566,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $i \\in \\{ 0 , 1 , . . . , H _ { q } W _ { q } - 1 \\}$ denotes the spatial index of query pixels. Since the query mask is not accessible, the label of query pixel $i ^ { \\star }$ is unknown. However, we can in turn find its most similar support pixel $j ^ { \\star }$ in the same way: ",
+        "bbox": [
+            174,
+            833,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b0560818ffb6e2ab74cbd59cda92d15367d6b97fb0671af25f8a1c8a077f4c22.jpg",
+        "text": "$$\nj ^ { \\star } = \\operatorname * { a r g m a x } _ { j } A _ { ( i ^ { \\star } , j ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            882,
+            571,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given the sampled support label $M _ { s } \\in \\mathbb { R } ^ { N _ { s } }$ , cycle-consistency is satisfied if $M _ { s ( j ) } = M _ { s ( j ^ { \\star } ) }$ Previous work [16] attempts to encourage the feature similarity between cycle-consistent pixels to improve the model’s generalization ability within the same set of categories. However, in few-shot segmentation, the goal is to enable the model to fast adapt to novel categories rather than making the model fit better to training categories. Thus, we incorporate the cycle-consistency into the attention operation to encourage the cycle-consistent cross-attention. First, by traversing all support tokens, an additive bias $B \\in \\mathbb { R } ^ { \\breve { N } _ { s } }$ is obtained by ",
+        "bbox": [
+            173,
+            89,
+            825,
+            189
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a314fda28f8cbb4ee99b4092260daea85d4710da2939124de7dfbcd05d059285.jpg",
+        "text": "$$\n{ \\cal B } _ { j } = \\left\\{ \\begin{array} { c l } { { 0 , } } & { { \\mathrm { i f } M _ { s ( j ) } = M _ { s ( j ^ { \\star } ) } } } \\\\ { { - \\infty , } } & { { \\mathrm { i f } M _ { s ( j ) } \\neq M _ { s ( j ^ { \\star } ) } } } \\end{array} \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            191,
+            629,
+            227
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $j \\in \\{ 0 , 1 , . . . , N _ { s } \\}$ . Then, for a single query token $Z _ { q ( i ) } \\in \\mathbb { R } ^ { d }$ at location $i$ , the support information is aggregated by ",
+        "bbox": [
+            173,
+            233,
+            818,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8275949aae33ab7c57f3adbc1a610b0489b5c550b6ccd5b3683981879afe266.jpg",
+        "text": "$$\n\\mathrm { C y C A t t e n } ( Q _ { i } , K _ { i } , V _ { i } ) = \\mathrm { s o f t m a x } ( A _ { ( i ) } + B ) V ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            266,
+            660,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $i \\in \\{ 0 , 1 , . . . , H _ { q } W _ { q } \\}$ and $A$ is obtained by $\\frac { Q K ^ { T } } { \\sqrt { d } }$ . In the forward process, $B$ is element-wise added with the affinity $A _ { ( i ) }$ for $Z _ { q ( i ) }$ to aggregate support features. In this way, the attention weight for the cycle-inconsistent support features become zero, implying that these irrelevant information will not be considered. Besides, the cycle-consistent attention implicitly encourages the consistency between the most relevant query and support pixel-wise features through backpropagation. Note that our method aims at removing support pixels with certain inconsistency, rather than ensuring all support pixels to form cycle-consistency, which is impossible without knowing the query ground truth labels. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            407
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When performing self-attention in the self-alignment block, there may also exist the same issue, i.e. the query token may attend to irrelevant or even harmful features (especially when background is complex). According to our cycle-consistent attention, each query token should receive information from more consistent pixels than aggregating from all pixels. Due to the lack of query mask $M _ { q }$ , it is impossible to establish the cycle-consistency among query pixels/tokens. Inspired by DeformableAttention [51], the consistent pixels can be obtained via a learnable way as $\\Delta \\bar { = } f ( Q \\bar { + }$ Coord) and $A ^ { ' } = g ( Q + \\mathrm { C o o r d } )$ , where $\\Delta \\in \\mathbb { R } ^ { H _ { p } W _ { p } \\times P }$ is the predicted consistent pixels, in which each element $\\delta \\in \\mathbb { R } ^ { P }$ in $\\Delta$ represents the relative offset from each pixel and $P$ represents the number of pixels to aggregate. And $\\mathbf { \\bar { \\Psi } } A ^ { ' } \\in \\mathbb { R } ^ { H _ { q } W _ { q } \\times P }$ is the attention weights. Coord $\\in \\mathbb { R } ^ { H _ { q } W _ { q } \\times d }$ is the positional encoding [24] to make the prediction be aware of absolute position, and $f ( \\cdot )$ and $g ( \\cdot )$ are two fully connected layers that predict the offsets4 and attention weights. Therefore, the self-attention within the self-alignment transformer block is represented as ",
+        "bbox": [
+            173,
+            412,
+            826,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3eb276720e4acd76696bebca521c6fb307794a06ad476c09e2ef390c77163184.jpg",
+        "text": "$$\n\\mathrm { P r e d A t t e n } ( Q _ { r } , V _ { r } ) = \\sum _ { g } ^ { P } \\mathrm { s o f t m a x } ( A ^ { ' } ) _ { ( r , g ) } V _ { r + \\Delta _ { ( r , g ) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            588,
+            679,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $r \\in \\{ 0 , 1 , . . . , H _ { q } W _ { q } \\}$ is the index of the flattened query feature, both $Q$ and $V$ are obtained by multiplying the flattened query feature with the learnable parameter. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Generally speaking, the cycle-consistent transformer effectively avoids the attention being biased by irrelevant features to benefit the training of few-shot segmentation. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Mask-guided sparse sampling and $K$ -shot Setting: Our proposed cycle-consistency transformer can be easily extended to $K$ -shot setting where $K > 1$ . When multiple support feature maps are provided, all support features are flattened and concatenated together as input. As the attention is performed at the pixel-level, the computation load will be high if the number of support pixels/tokens is large, which is usually the case under $K$ -shot setting. In this work, we apply a simple mask-guided sampling strategy to reduce the computation complexity and make our method more scalable. Concretely, given the $k$ -shot support sequence $Z _ { s } \\in \\bar { \\mathbb R } ^ { k H _ { s } \\bar { W } _ { s } \\times d }$ and the flattened support masks $M _ { s } \\in \\mathbb { R } ^ { k H _ { s } W _ { s } }$ , the support pixels/tokens are obtained by uniformly sampling $N _ { f g }$ tokens $\\begin{array} { r } { ( N _ { f g } \\ < = \\ \\frac { N _ { s } } { 2 } } \\end{array}$ , where $N _ { s } \\le k H _ { s } W _ { s } )$ from the foreground regions and $N _ { s } - N _ { f g }$ tokens from the background regions in all support images. With a proper $N _ { s }$ , the sampling operation reduces the computational complexity, and makes our algorithm more scalable with the increase of spatial size of support images. Additionally, this strategy helps balance the foreground-background ratio and also implicitly considers different sizes of various object regions in support images. ",
+        "bbox": [
+            173,
+            705,
+            826,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/992075d40416fe3ea1e0bc8c626f95f0fcd2bd23c744b6420840298262718635.jpg",
+        "table_caption": [
+            "Table 1: Comparison with other state-of-the-art methods for 1-shot and 5-shot segmentation on PASCAL- $. 5 ^ { i }$ using the mIoU $( \\% )$ evaluation metric. Best results are shown in bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Backbone</td><td colspan=\"5\">1-shot</td><td colspan=\"5\">5-shot</td></tr><tr><td>50</td><td>5</td><td>52</td><td>5</td><td>Mean</td><td>50</td><td>5</td><td>5²</td><td>53</td><td>Mean</td></tr><tr><td>PANet [35]</td><td rowspan=\"3\">Vgg-16</td><td>42.3</td><td>58.0</td><td>51.1</td><td>41.2</td><td>48.1</td><td>51.8</td><td>64.6</td><td>59.8</td><td>46.5</td><td>55.7</td></tr><tr><td>FWB [23]</td><td>47.0</td><td>59.6</td><td>52.6</td><td>48.3</td><td>51.9</td><td>50.9</td><td>62.9</td><td>56.5</td><td>50.1</td><td>55.1</td></tr><tr><td>SG-One [46]</td><td>40.2</td><td>58.4</td><td>48.4</td><td>38.4</td><td>46.3</td><td>41.9</td><td>58.6</td><td>48.6</td><td>39.4</td><td>47.1</td></tr><tr><td>RPMM [41]</td><td rowspan=\"4\">Res-50</td><td>47.1</td><td>65.8</td><td>50.6</td><td>48.5</td><td>53.0</td><td>50.0</td><td>66.5</td><td>51.9</td><td>47.6</td><td>54.0</td></tr><tr><td>CANet [44]</td><td>52.5</td><td>65.9</td><td>51.3</td><td>51.9</td><td>55.4</td><td>55.5</td><td>67.8</td><td>51.9</td><td>53.2</td><td>57.1</td></tr><tr><td>PGNet [43]</td><td>56.0</td><td>66.9</td><td>50.6</td><td>50.4</td><td>56.0</td><td>57.7</td><td>68.7</td><td>52.9</td><td>54.6</td><td>58.5</td></tr><tr><td>RPMM [41]</td><td>55.2 47.8</td><td>66.9</td><td>52.6 53.8</td><td>50.7</td><td>56.3</td><td>56.3</td><td>67.3</td><td>54.5</td><td>51.0</td><td>57.3</td></tr><tr><td>PPNet [18]</td><td></td><td></td><td>58.8</td><td></td><td>45.6</td><td>51.5</td><td>58.4</td><td>67.8</td><td>64.9</td><td>56.7</td><td>62.0</td></tr><tr><td>PFENet [30]</td><td>Res-50</td><td>61.7</td><td>69.5</td><td>55.4</td><td>56.3</td><td>60.8</td><td>63.1</td><td>70.7</td><td>55.8</td><td>57.9</td><td>61.9</td></tr><tr><td>CyCTR (Ours)</td><td></td><td>65.7</td><td>71.0</td><td>59.5</td><td>59.7</td><td>64.0</td><td>69.3</td><td>73.5</td><td>63.8</td><td>63.5</td><td>67.5</td></tr><tr><td>FWB [23]</td><td>Res-101</td><td>51.3</td><td>64.5</td><td>56.7</td><td>52.2</td><td>56.2</td><td>54.9</td><td>67.4</td><td>62.2</td><td>55.3</td><td>59.9</td></tr><tr><td>DAN [34]</td><td></td><td>54.7</td><td>68.6</td><td>57.8</td><td>51.6</td><td>58.2</td><td>57.9</td><td>69.0</td><td>60.1</td><td>54.9</td><td>60.5</td></tr><tr><td>PFENet [30]</td><td>Res-101</td><td>60.5</td><td>69.4</td><td>54.4</td><td>55.9</td><td>60.1</td><td>62.8</td><td>70.4</td><td>54.9</td><td>57.6</td><td>61.4</td></tr><tr><td>CyCTR (Ours)</td><td></td><td>67.2</td><td>71.1</td><td>57.6</td><td>59.0</td><td>63.7</td><td>71.0</td><td>75.0</td><td>58.5</td><td>65.0</td><td>67.4</td></tr></table>",
+        "bbox": [
+            173,
+            126,
+            825,
+            340
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Overall Framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            366,
+            351,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Following previous works [30, 35, 44], both query and support images are first feed into a shared backbone (e.g., ResNet [12]) which is initialized with weights pretrained from ImageNet [25] to obtain general image features. Similar to [30], middle-level query features (the concatenation of query features from the $3 ^ { r d }$ and the $4 ^ { t h }$ blocks of ResNet) are processed by a $1 \\times 1$ convolution to reduce the hidden dimension. The high-level query features (from the $5 ^ { t h }$ block) are used to generate a prior map (the prior map is generated by calculating the pixel-wise similarity between query and support features, details can be found in the supplementary materials) and then are concatenated with the middle-level query features. The average masked support feature is also concatenated to provide global support information. The concatenated features are processed by a $1 \\times 1$ convolution. The output query features are then fed into our proposed CyCTR encoders. The output of CyCTR encoders is fed into a classifier to obtain the final segmentation results. The classifier consists of a $3 \\times 3$ convolutional layer, a ReLU layer and a $1 \\times 1$ convolutional layer. More details about our network structure can be found in the supplementary materials. ",
+        "bbox": [
+            173,
+            391,
+            825,
+            571
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            590,
+            312,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Dataset and Evaluation Metric ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            426,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on two commonly used few-shot segmentation datasets, Pascal- ${ \\cdot } 5 ^ { i }$ [10] (which is combined with SBD [11] dataset) and COCO- $2 0 ^ { i }$ [17], to evaluate our method. For Pascal$5 ^ { i }$ , 20 classes are separated into 4 splits. For each split, 15 classes are used for training and 5 classes for test. At the test time, 1,000 pairs that belong to the testing classes are sampled from the validation set for evaluation. In $\\mathrm { C O C O - 2 0 ^ { i } }$ , we follow the data split settings in FWB [23] to divide 80 classes evenly into 4 splits, 60 classes for training and test on 20 classes, and 5,000 validation pairs from the 20 classes are sampled for evaluation. Detailed data split settings can be found in the supplementary materials. Following common practice [30, 35, 46], the mean intersection over union (mIoU) is adopted as the evaluation metric, which is the averaged value of IoU of all test classes. We also report the foreground-background IoU (FB-IoU) for comparison. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            786
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            377,
+            818
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, the training strategies follow the same setting in [30]: training for 50 epochs on $\\mathrm { C O C O - 2 0 } ^ { i }$ and 200 epochs on Pascal- $5 ^ { i }$ . Images are resized and cropped to $4 7 3 \\times 4 7 3$ for both datasets and we use random rotation from $- 1 0 ^ { \\circ }$ to $1 0 ^ { \\circ }$ as data augmentation. Besides, we use ImageNet [25] pretrained ResNet [12] as the backbone network and its parameters (including BatchNorms) are freezed. For the parameters except those in the transformer layers, we use the initial learning rate $2 . 5 \\times 1 0 ^ { - 3 }$ , momentum 0.9, weight decay $1 \\times 1 0 ^ { - 4 }$ and SGD optimizer with poly learning rate decay [4]. The mini batch size on each gpu is set to 4. Experiments are carried out on Tesla V100 GPUs. For Pascal- ${ \\cdot } 5 ^ { i }$ , one model is trained on a single GPU, while for $\\mathrm { C O C O - 2 0 ^ { i } }$ , one model is trained with 4 GPUs. We construct our baseline as follows: as stated in Section 3.4, the middle-level query features from backbone network are concatenated and merged with the global support feature and the prior map. This feature is processed by two residule blocks and input to the same classifier as our method. Dice loss [21] is used as the training objective. Besides, the middle-level query feature is averaged using the ground truth and concatenated with support feature to predict the support segmentation map, which produces an auxiliary loss for aligning features. The same settings are also used in our method except that we use our cycle-consistent transformer to process features rather than the residule blocks. For the proposed cycle-consistent transformer, we set the number of sampled support tokens $N _ { s }$ to 600 for 1-shot and $5 \\times 6 0 0$ for 5-shot setting. The number of sampled tokens is obtained according to the averaged number of foreground pixels among Pascal- ${ \\cdot } 5 ^ { i }$ training set. For the self-attention block, the number of points $P$ is set to 9. For other hyper-parameters in transformer blocks, we use $L = 2$ transformer encoders. We set the hidden dimension of MLP layer to $3 \\times 2 5 6$ and that of input to 256. The number of heads for all attention layers is set to 8 for Pascal- ${ \\cdot } 5 ^ { i }$ and 1 for $\\mathrm { C O C O - 2 0 } ^ { \\bar { i } }$ . Parameters in the transformer blocks are optimized with AdamW [20] optimizer following other transformer works [3, 8, 31], with learning rate $1 \\times 1 0 ^ { - 4 }$ and weight decay $1 \\times 1 0 ^ { - 2 }$ . Besides, we use Dropout with the probability 0.1 in all attention layers. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/17467bfad6aebc32c3a1da7b095b908b3179c7a31dd248072f39165b2c565e48.jpg",
+        "table_caption": [
+            "Table 2: Comparison with other state-of-the-art methods for 1-shot and 5-shot segmentation on COCO- ${ \\it 2 0 ^ { i } }$ using the mIoU $( \\% )$ evaluation metric. Best results are shown in bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Backbone</td><td colspan=\"5\">1-shot</td><td colspan=\"5\">5-shot</td></tr><tr><td>200</td><td>201</td><td>20</td><td>20</td><td>Mean</td><td>200</td><td>201</td><td>20</td><td>20</td><td>Mean</td></tr><tr><td>FWB [23]</td><td>Res-101</td><td>19.9</td><td>18.0</td><td>21.0</td><td>28.9</td><td>21.2</td><td>19.1</td><td>21.5</td><td>23.9</td><td>30.1</td><td>23.7</td></tr><tr><td>PPNet[18]</td><td>Res-50</td><td>28.1</td><td>30.8</td><td>29.5</td><td>27.7</td><td>29.0</td><td>39.0</td><td>40.8</td><td>37.1</td><td>37.3</td><td>38.5</td></tr><tr><td>RPMM [41]</td><td>Res-50</td><td>29.5</td><td>36.8</td><td>29.0</td><td>27.0</td><td>30.6</td><td>33.8</td><td>42.0</td><td>33.0</td><td>33.3</td><td>35.5</td></tr><tr><td>PFENet [30]</td><td>Res-101</td><td>34.3</td><td>33.0</td><td>32.3</td><td>30.1</td><td>32.4</td><td>38.5</td><td>38.6</td><td>38.2</td><td>34.3</td><td>37.4</td></tr><tr><td>CyCTR (Ours)</td><td>Res-50</td><td>38.9</td><td>43.0</td><td>39.6</td><td>39.8</td><td>40.3</td><td>41.1</td><td>48.9</td><td>45.2</td><td>47.0</td><td>45.6</td></tr></table>",
+        "bbox": [
+            173,
+            126,
+            825,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            256,
+            826,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Comparisons with State-of-the-Art Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            542,
+            519,
+            556
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 1 and Table 2, we compare our method with other state-of-the-art few-shot segmentation approaches on Pascal- ${ \\cdot } 5 ^ { i }$ and $\\mathrm { C O C O - 2 0 ^ { i } }$ respectively. It can be seen that our approach achieves new state-of-the-art performance on both Pascal- $5 ^ { i }$ ",
+        "bbox": [
+            171,
+            570,
+            825,
+            611
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "and $\\mathrm { C O C O - 2 0 ^ { i } }$ . Specifically, on Pascal- $5 ^ { i }$ , to make fair comparisons with other methods, we report results with both ResNet-50 and ResNet101. Our CyCTR achieves $6 4 . 0 \\%$ mIoU with ResNet-50 backbone and $6 3 . 7 \\%$ mIoU with ResNet-101 backbone for 1-shot segmentation, significantly outperforming previous state-ofthe-art results by $3 . 2 \\%$ and $3 . 6 \\%$ , respectively. For 5-shot segmentation, our CyCTR can even surpass state-of-the art methods by $5 . 6 \\%$ and $6 . 0 \\%$ mIoU when using ResNet-50 and ResNet",
+        "bbox": [
+            174,
+            606,
+            485,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1f1422244e2e05f0d190051e0e14e984801e03e7c1a34c2dc7d258b1215c25df.jpg",
+        "table_caption": [
+            "Table 3: Comparison with other methods using FB-IoU $( \\% )$ on Pascal- ${ \\cdot } 5 ^ { i }$ for 1-shot and 5-shot segmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Backbone</td><td>FB-IoU (%)</td></tr><tr><td>1-shot 5-shot</td></tr><tr><td>A-MCG [13]</td><td>Res-101</td><td>61.2 62.2</td></tr><tr><td>DAN [34]</td><td>Res-101</td><td>71.9 72.3</td></tr><tr><td>PFENet [30]</td><td>Res-101</td><td>72.9 73.5</td></tr><tr><td>CyCTR (Ours)</td><td>Res-101</td><td>73.0 75.4</td></tr></table>",
+        "bbox": [
+            496,
+            661,
+            823,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "101 backbones respectively. For $\\mathrm { C O C O - 2 0 ^ { i } }$ results in Table 2, our method also outperforms other methods by a large margin due to the capability of the transformer to fit more complex data. Besides, Table 3 shows the comparison using FB-IoU on PASCAL- ${ \\cdot } 5 ^ { i }$ for 1-shot and 5-shot segmentation, our method also obtains the state-of-the-art performance. ",
+        "bbox": [
+            174,
+            763,
+            826,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            328,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To provide a deeper understanding of our proposed method, we show ablation studies in this section. The experiments are performed on Pascal- $5 ^ { i }$ 1-shot setting with ResNet-50 as the backbone network, and results are reported in terms of mIoU. ",
+        "bbox": [
+            174,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/389dc8bcdae74a45e9d8860513e7ee91910a5a6adddc281ae5328b5c157a5ca9.jpg",
+        "table_caption": [
+            "Table 4: Ablation studies that validate the effectiveness of each component in our Cycle-Consistent TRansformer. The first result is obtained by our baseline (see Section 4.2 for details). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>self-alignment</td><td>cross-alignment</td><td>CyCTR (pred)</td><td>CyCTR (fg. only)</td><td>CyCTR</td><td>mIoU (%)</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>59.3 62.5</td></tr><tr><td>&gt;&gt;&gt;</td><td></td><td></td><td></td><td></td><td>62.9</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>62.6</td></tr><tr><td></td><td>&gt;&gt;&gt;</td><td>√</td><td>厂</td><td></td><td>63.0</td></tr><tr><td>广</td><td>√</td><td></td><td></td><td>√</td><td>63.5</td></tr></table>",
+        "bbox": [
+            174,
+            126,
+            823,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4.1 Component-Wise Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            260,
+            416,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We perform ablation studies regarding each component of our CyCTR in Table 4. The first line is the result of our baseline, where we use two residual blocks to merge features as stated in Section 4.2. For all ablations in Table 4, the hidden dimension is set to 128 and two transformer encoders are used. The mIoU results are averaged over four splits. Firstly, we only use the self-alignment block that only encodes query features. The support information in this case comes from the concatenated global support feature and the prior map used in [44]. It can already bring decent results, showing that the transformer encoder is effective for modeling context for few-shot segmentation. Then, we utilize the cross-alignment block but only with the vanilla attention operation in Equation 1. The mIoU increases by $0 . 4 \\%$ , indicating that pixel-level features from support can provide additional performance gain. By using our proposed cycle-consistent attention module, the performance can be further improved by a large margin, i.e. $0 . 6 \\%$ mIoU compared to the vanilla attention. This result demonstrates our cycle-consistent attention’s capability to suppress possible harmful information from support. Besides, we assume some background support features may also benefit the query segmentation and therefore use the cycle-consistent transformer to aggregate pixel-level information from background support features as well. Comparing the last two lines in Table 4, we show that our way of utilizing beneficial background pixel-level support information brings $0 . 5 \\%$ mIoU improvement, validating our assumption and the effectiveness of our proposed cycle-consistent attention operation. ",
+        "bbox": [
+            173,
+            284,
+            826,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Besides, one may be curious about whether the noise can also be removed by predicting the aggregation position like the way in Equation 6 for aggregating support features to query. Therefore, we use predicted aggregation instead of the cycle-consistent attention in the cross-alignment block, as denoted by $C y C T R ( p r e d )$ in Table 4. It does benefit the few-shot segmentation by aggregating useful information from support but is $0 . 9 \\%$ worse than the proposed cycle-consistent attention. The reason lies in the dramatically changing support images under few-shot segmentation testing. The cycle-consistency is better than the learnable way as it can globally consider the varying conditional information from both query and support. ",
+        "bbox": [
+            174,
+            525,
+            826,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4.2 Effect of Model Capacity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            650,
+            398,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We can stack more encoders or increase the hidden dimension of encoders to increase its capacity and validate the effectiveness of our CyCTR. The results with different numbers of encoders (denoted as $L$ ) or hidden dimensions (denoted as $d$ ) are shown in Table 5a and 5b. While increasing $L$ or $d$ within a certain range, CyCTR achieves better results. We chose $L = 2$ as our default choice for accuracy-efficiency trade-off. ",
+        "bbox": [
+            174,
+            675,
+            485,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0f1786103a41b989f81dd12d1ef53c7ac4ff98c0030b717996ded320efec2e54.jpg",
+        "table_caption": [
+            "Table 5: Effect of varying (a) number of encoders $L$ and (b) hidden dimensions $d$ . When varying $L$ , $d$ is fixed to 128; while varying $d , L$ is fixed to 2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>#Encoder</td><td>mIoU (%)</td><td>#Dim</td><td>mIoU (%)</td></tr><tr><td>1</td><td>62.4</td><td>128</td><td>63.5</td></tr><tr><td>2</td><td>63.5</td><td>256</td><td>64.0</td></tr><tr><td>3</td><td>63.7</td><td>384</td><td>63.9</td></tr><tr><td colspan=\"2\">(a)</td><td colspan=\"2\">(b)</td></tr></table>",
+        "bbox": [
+            500,
+            726,
+            810,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Qualitative results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            816,
+            339,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, we show some qualitative results generated by our model on Pascal- $5 ^ { i }$ . Our cycleconsistent attention can improve the segmentation quality by suppressing possible harmful information from support. For instance, without cycle-consistency, the model misclassifies trousers as “cow” in the first row, baby’s hair as “cat” in the second row, and a fraction of mountain as “car” in the third row, while our model rectifies these part as background. However, in the first row, our CyCTR still segments part of the trousers as \"cow\" and the right boundary of the segmentation mask is slightly worse than the model without cycle-consistency. The reason comes from the extreme differences between query and support, i.e. the support image shows a \"cattle\" but the query image contains a milk cow. The cycle-consistency may over-suppress the positive region in support images. Solving such issue may be a potential direction to investigate to improve our method further. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/13eb69bca8df05815dd7d37e102ac9b3e39ea306bd9e3859ce1a7c776634e965.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative results on Pascal- ${ \\cdot } 5 ^ { i }$ . From left to right, each column shows the examples of: Support image with mask region in red; Query image with ground truth mask region in blue; Result produced by the model without cycle-consistency in CyCTR; Result produced by our method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            90,
+            818,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            388,
+            825,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            299,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we design a CyCTR module to deal with the few-shot segmentation problem. Different from previous practices that either adopt semantic-level prototype(s) from support images or only use foreground support features to encode query features, our CyCTR utilizes all pixel-level support features and can effectively eliminate aggregating confusing and harmful support features with the proposed novel cycle-consistency attention. We conduct extensive experiments on two popular benchmarks, and our CyCTR outperforms previous state-of-the-art methods by a significant margin. We hope this work can motivate researchers to utilize pixel-level support features to design more effective algorithms to advance the few-shot segmentation research. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            619
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            266,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   \n[2] Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   \n[3] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pages 213–229. Springer, 2020.   \n[4] Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. IEEE transactions on pattern analysis and machine intelligence, 40(4):834–848, 2017.   \n[5] Rewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   \n[6] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   \n[7] Nanqing Dong and Eric P Xing. Few-shot semantic segmentation with prototype learning. In BMVC, volume 3-4, 2018.   \n[8] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   \n[9] Debidatta Dwibedi, Yusuf Aytar, Jonathan Tompson, Pierre Sermanet, and Andrew Zisserman. Temporal cycle-consistency learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1801–1810, 2019.   \n[10] Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. International journal of computer vision, 88(2):303–338, 2010.   \n[11] Bharath Hariharan, Pablo Arbeláez, Ross Girshick, and Jitendra Malik. Simultaneous detection and segmentation. In European Conference on Computer Vision, pages 297–312. Springer, 2014.   \n[12] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), pages 770–778, 2016.   \n[13] Tao Hu, Pengwan Yang, Chiliang Zhang, Gang Yu, Yadong Mu, and Cees GM Snoek. Attentionbased multi-context guiding for few-shot semantic segmentation. In Association for the Advancement of Artificial Intelligence (AAAI), volume 33, pages pp. 8441–8448, 2019.   \n[14] Zilong Huang, Xinggang Wang, Lichao Huang, Chang Huang, Yunchao Wei, and Wenyu Liu. Ccnet: Criss-cross attention for semantic segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 603–612, 2019.   \n[15] Zilong Huang, Xinggang Wang, Jiasi Wang, Wenyu Liu, and Jingdong Wang. Weaklysupervised semantic segmentation network with deep seeded region growing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7014–7023, 2018.   \n[16] Guoliang Kang, Yunchao Wei, Yi Yang, Yueting Zhuang, and Alexander G Hauptmann. Pixellevel cycle association: A new perspective for domain adaptive semantic segmentation. In NeurIPS, 2020.   \n[17] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision (ECCV), 2014.   \n[18] Yongfei Liu, Xiangyi Zhang, Songyang Zhang, and Xuming He. Part-aware prototype network for few-shot semantic segmentation. In European Conference on Computer Vision, pages 142–158. Springer, 2020.   \n[19] Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 3431–3440, 2015.   \n[20] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.   \n[21] Fausto Milletari, Nassir Navab, and Seyed-Ahmad Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In 2016 fourth international conference on 3D vision (3DV), pages 565–571. IEEE, 2016.   \n[22] Juhong Min, Dahyun Kang, and Minsu Cho. Hypercorrelation squeeze for few-shot segmentation. arXiv preprint arXiv:2104.01538, 2021.   \n[23] Khoi Nguyen and Sinisa Todorovic. Feature weighting and boosting for few-shot segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 622–631, 2019.   \n[24] Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image transformer. In International Conference on Machine Learning, pages 4055–4064. PMLR, 2018.   \n[25] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.   \n[26] Amirreza Shaban, Shray Bansal, Zhen Liu, Irfan Essa, and Byron Boots. One-shot learning for semantic segmentation. In British Machine Vision Conference (BMVC), 2018.   \n[27] Han Shi, Jiahui Gao, Xiaozhe Ren, Hang Xu, Xiaodan Liang, Zhenguo Li, and James T Kwok. Sparsebert: Rethinking the importance analysis in self-attention. arXiv preprint arXiv:2102.12871, 2021.   \n[28] Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in neural information processing systems (NeurIPS), 2017.   \n[29] Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1199–1208, 2018.   \n[30] Z Tian, H Zhao, M Shu, Z Yang, R Li, and J Jia. Prior guided feature enrichment network for few-shot segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.   \n[31] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   \n[32] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 6000–6010, 2017.   \n[33] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   \n[34] Haochen Wang, Xudong Zhang, Yutao Hu, Yandan Yang, Xianbin Cao, and Xiantong Zhen. Few-shot semantic segmentation with democratic attention networks. In European Conference on Computer Vision (ECCV), 2020.   \n[35] Kaixin Wang, Jun Hao Liew, Yingtian Zou, Daquan Zhou, and Jiashi Feng. Panet: Few-shot image semantic segmentation with prototype alignment. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9197–9206, 2019.   \n[36] Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 7794–7803, 2018.   \n[37] Xiaolong Wang, Allan Jabri, and Alexei A Efros. Learning correspondence from the cycleconsistency of time. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2566–2576, 2019.   \n[38] Yunchao Wei, Jiashi Feng, Xiaodan Liang, Ming-Ming Cheng, Yao Zhao, and Shuicheng Yan. Object region mining with adversarial erasing: A simple classification to semantic segmentation approach. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1568–1576, 2017.   \n[39] Yunchao Wei, Huaxin Xiao, Honghui Shi, Zequn Jie, Jiashi Feng, and Thomas S Huang. Revisiting dilated convolution: A simple approach for weakly-and semi-supervised semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7268–7277, 2018.   \n[40] Yangxin Wu, Gengwei Zhang, Yiming Gao, Xiajun Deng, Ke Gong, Xiaodan Liang, and Liang Lin. Bidirectional graph reasoning network for panoptic segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9080–9089, 2020.   \n[41] Boyu Yang, Chang Liu, Bohao Li, Jianbin Jiao, and Qixiang Ye. Prototype mixture models for few-shot semantic segmentation. In European Conference on Computer Vision, pages 763–778. Springer, 2020.   \n[42] Lihe Yang, Wei Zhuo, Lei Qi, Yinghuan Shi, and Yang Gao. Mining latent classes for few-shot segmentation. arXiv preprint arXiv:2103.15402, 2021.   \n[43] Chi Zhang, Guosheng Lin, Fayao Liu, Jiushuang Guo, Qingyao Wu, and Rui Yao. Pyramid graph networks with connection attentions for region-based one-shot semantic segmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9587–9595, 2019.   \n[44] Chi Zhang, Guosheng Lin, Fayao Liu, Rui Yao, and Chunhua Shen. Canet: Class-agnostic segmentation networks with iterative refinement and attentive few-shot learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5217–5226, 2019.   \n[45] Shiyin Zhang, Jun Hao Liew, Yunchao Wei, Shikui Wei, and Yao Zhao. Interactive object segmentation with inside-outside guidance. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12234–12244, 2020.   \n[46] Xiaolin Zhang, Yunchao Wei, Yi Yang, and Thomas S Huang. Sg-one: Similarity guidance network for one-shot semantic segmentation. IEEE Transactions on Cybernetics, 50(9):3855– 3865, 2020.   \n[47] Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In Proceedings of the IEEE conference on computer vision and pattern recognition (CVPR), 2017.   \n[48] Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Scene parsing through ade20k dataset. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 633–641, 2017.   \n[49] Tinghui Zhou, Philipp Krahenbuhl, Mathieu Aubry, Qixing Huang, and Alexei A Efros. Learning dense correspondence via 3d-guided cycle consistency. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 117–126, 2016.   \n[50] Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE international conference on computer vision, pages 2223–2232, 2017.   \n[51] Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, and Jifeng Dai. Deformable detr: Deformable transformers for end-to-end object detection. arXiv preprint arXiv:2010.04159, 2020. ",
+        "bbox": [
+            181,
+            664,
+            828,
+            910
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            66,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            66,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            534
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SSnY462CYz1Cu/SSnY462CYz1Cu.md

@@ -0,0 +1,558 @@
+# Knowledge Matters: Importance of Prior Information for Optimization
+
+C¸ a˘glar G¨ul¸cehre D´epartement d’informatique et de recherche op´erationnelle Universit´e de Montr´eal, Montr´eal, QC, Canada
+
+gulcehrc@iro.umontreal.ca
+
+Yoshua Bengio D´epartement d’informatique et de recherche op´erationnelle Universit´e de Montr´eal, Montr´eal, QC, Canada
+
+bengioy@iro.umontreal.ca
+
+Editor: Not Assigned
+
+# Abstract
+
+We explore the effect of introducing prior information into the intermediate level of deep supervised neural networks for a learning task on which all the black-box state-of-the-art machine learning algorithms tested have failed to learn. We motivate our work from the hypothesis that there is an optimization obstacle involved in the nature of such tasks, and that humans learn useful intermediate concepts from other individuals via a form of supervision or guidance using a curriculum. The experiments we have conducted provide positive evidence in favor of this hypothesis. In our experiments, a two-tiered MLP architecture is trained on a dataset for which each image input contains three sprites, and the binary target class is 1 if all three have the same shape. Black-box machine learning algorithms only got chance on this task. Standard deep supervised neural networks also failed. However, using a particular structure and guiding the learner by providing intermediate targets in the form of intermediate concepts (the presence of each object) allows to nail the task. Much better than chance but imperfect results are also obtained by exploring architecture and optimization variants, pointing towards a difficult optimization task. We hypothesize that the learning difficulty is due to the composition of two highly non-linear tasks. Our findings are also consistent with hypotheses on cultural learning inspired by the observations of effective local minima (possibly due to ill-conditioning and the training procedure not being able to escape what appears like a local minimum).
+
+Keywords: Deep Learning, Neural Networks, Optimization, Evolution of Culture, Curriculum Learning, Training with Hints
+
+# 1. Introduction
+
+There is a recent emerging interest in different fields of science for cultural learning (Henrich and McElreath, 2003) and how groups of individuals exchanging information can learn in ways superior to individual learning. This is also witnessed by the emergence of new research fields such as ”Social Neuroscience”. Learning from other agents in an environment by the means of cultural transmission of knowledge with a peer-to-peer communication is an efficient and natural way of acquiring or propagating common knowledge. The most popular belief on how the information is transmitted between individuals is that bits of information are transmitted by small units, called memes, which share some characteristics of genes, such as self-replication, mutation and response to selective pressures (Dawkins, 1976).
+
+This paper is based on the hypothesis (which is further elaborated in Bengio (2013a)) that human culture and the evolution of ideas have been crucial to counter an optimization issue: this difficulty would otherwise make it difficult for human brains to capture high level knowledge of the world without the help of other educated humans. In this paper machine learning experiments are used to investigate some elements of this hypothesis by seeking answers for the following questions: are there machine learning tasks which are intrinsically hard for a lone learning agent but that may become very easy when intermediate concepts are provided by another agent as additional intermediate learning cues, in the spirit of Curriculum Learning (Bengio et al., 2009b)? What makes such learning tasks more difficult? Can specific initial values of the neural network parameters yield success when random initialization yield complete failure? Is it possible to verify that the problem being faced is an optimization problem or with a regularization problem? These are the questions discussed (if not completely addressed) here, which relate to the following broader question: how can humans (and potentially one day, machines) learn complex concepts?
+
+In this paper, results of different machine learning algorithms on an artificial learning task involving binary 64 $\times$ 64 images are presented. In that task, each image in the dataset contains 3 Pentomino tetris sprites (simple shapes). The task is to figure out if all the sprites in the image are the same or if there are different sprite shapes in the image. Several state-of-the-art machine learning algorithms have been tested and none of them could perform better than a random predictor on the test set. Nevertheless by providing hints about the intermediate concepts (the presence and location of particular sprite classes), the problem can easily be solved where the same-architecture neural network without the intermediate concepts guidance fails. Surprisingly, our attempts at solving this problem with unsupervised pre-training algorithms failed solve this problem. However, with specific variations in the network architecture or training procedure, it is found that one can make a big dent in the problem. For showing the impact of intermediate level guidance, we experimented with a two-tiered neural network, with supervised pre-training of the first part to recognize the category of sprites independently of their orientation and scale, at different locations, while the second part learns from the output of the first part and predicts the binary task of interest.
+
+The objective of this paper is not to propose a novel learning algorithm or architecture, but rather to refine our understanding of the learning difficulties involved with composed tasks (here a logical formula composed with the detection of object classes), in particular the training difficulties involved for deep neural networks. The results also bring empirical evidence in favor of some of the hypotheses from Bengio (2013a), discussed below, as well as introducing a particular form of curriculum learning (Bengio et al., 2009b).
+
+Building difficult AI problems has a long history in computer science. Specifically hard AI problems have been studied to create CAPTCHA’s that are easy to solve for humans, but hard to solve for machines (Von Ahn et al., 2003). In this paper we are investigating a difficult problem for the off-the-shelf black-box machine learning algorithms.1
+
+# 1.1 Curriculum Learning and Cultural Evolution Against Effective Local Minima
+
+What Bengio (2013a) calls an effective local minimum is a point where iterative training stalls, either because of an actual local minimum or because the optimization algorithm is unable (in reasonable time) to find a descent path (e.g., because of serious ill-conditioning). In this paper, it is hypothesized that some more abstract learning tasks such as those obtained by composing simpler tasks are more likely to yield effective local minima for neural networks, and are generally hard for general-purpose machine learning algorithms.
+
+The idea that learning can be enhanced by guiding the learner through intermediate easier tasks is old, starting with animal training by shaping (Skinner, 1958; Peterson, 2004; Krueger and Dayan, 2009). Bengio et al. (2009b) introduce a computational hypothesis related to a presumed issue with effective local minima when directly learning the target task: the good solutions correspond to hard-to-find-by-chance effective local minima, and intermediate tasks prepare the learner’s internal configuration (parameters) in a way similar to continuation methods in global optimization (which go through a sequence of intermediate optimization problems, starting with a convex one where local minima are no issue, and gradually morphing into the target task of interest).
+
+In a related vein, Bengio (2013a) makes the following inferences based on experimental observations of deep learning and neural network learning:
+
+Point 1: Training deep architectures is easier when some hints are given about the function that the intermediate levels should compute (Hinton et al., 2006; Weston et al., 2008; Salakhutdinov and Hinton, 2009; Bengio, 2009). The experiments performed here expand in particular on this point.
+
+Point 2: It is much easier to train a neural network with supervision (where examples ar provided to it of when a concept is present and when it is not present in a variety of examples) than to expect unsupervised learning to discover the concept (which may also happen but usually leads to poorer renditions of the concept). The poor results obtained with unsupervised pre-training reinforce that hypothesis.
+
+Point 3: Directly training all the layers of a deep network together not only makes it difficult to exploit all the extra modeling power of a deeper architecture but in many cases it actually yields worse results as the number of required layers is increased (Larochelle et al., 2009; Erhan et al., 2010). The experiments performed here also reinforce that hypothesis.
+
+Point 4: Erhan et al. (2010) observed that no two training trajectories ended up in the same effective local minimum, out of hundreds of runs, even when comparing solutions as functions from input to output, rather than in parameter space (thus eliminating from the picture the presence of symmetries and multiple local minima due to relabeling and other reparametrizations). This suggests that the number of different effective local minima (even when considering them only in function space) must be huge.
+
+Point 5: Unsupervised pre-training, which changes the initial conditions of the descent procedure, sometimes allows to reach substantially better effective local minima (in terms of generalization error!), and these better local minima do not appear to be reachable by chance alone (Erhan et al., 2010). The experiments performed here provide another piece of evidence in favor of the hypothesis that where random initialization can yield rather poor results, specifically targeted initialization can have a drastic impact, i.e., that effective local minima are not just numerous but that some small subset of them are much better and hard to reach by chance.2
+
+Based on the above points, Bengio (2013a) then proposed the following hypotheses regarding learning of high-level abstractions.
+
+• Optimization Hypothesis: When it learns, a biological agent performs an approximate optimization with respect to some implicit objective function.
+
+• Deep Abstractions Hypothesis: Higher level abstractions represented in brains require deeper computations (involving the composition of more non-linearities).
+
+• Local Descent Hypothesis: The brain of a biological agent relies on approximate local descent and gradually improves itself while learning.
+
+• Effective Local Minima Hypothesis: The learning process of a single human learner (not helped by others) is limited by effective local minima.
+
+• Deeper Harder Hypothesis: Effective local minima are more likely to hamper learning as the required depth of the architecture increases.
+
+• Abstractions Harder Hypothesis: High-level abstractions are unlikely to be discovered by a single human learner by chance, because these abstractions are represented by a deep subnetwork of the brain, which learns by local descent.
+
+• Guided Learning Hypothesis: A human brain can learn high level abstractions if guided by the signals produced by other agents that act as hints or indirect supervision for these high-level abstractions.
+
+• Memes Divide-and-Conquer Hypothesis: Linguistic exchange, individual learning and the recombination of memes constitute an efficient evolutionary recombination operator in the meme-space. This helps human learners to collectively build better internal representations of their environment, including fairly high-level abstractions.
+
+This paper is focused on “Point 1 ” and testing the “Guided Learning Hypothesis”, using machine learning algorithms to provide experimental evidence. The experiments performed also provide evidence in favor of the “Deeper Harder Hypothesis” and associated “Abstractions Harder Hypothesis”. Machine Learning is still far beyond the current capabilities of humans, and it is important to tackle the remaining obstacles to approach AI. For this purpose, the question to be answered is why tasks that humans learn effortlessly from very few examples, while machine learning algorithms fail miserably?
+
+# 2. Culture and Optimization Difficulty
+
+As hypothesized in the “Local Descent Hypothesis”, human brains would rely on a local approximate descent, just like a Multi-Layer Perceptron trained by a gradient-based iterative optimization. The main argument in favor of this hypothesis relies on the biologically-grounded assumption that although firing patterns in the brain change rapidly, synaptic strengths underlying these neural activities change only gradually, making sure that behaviors are generally consistent across time. If a learning algorithm is based on a form of local (e.g. gradient-based) descent, it can be sensitive to effective local minima (Bengio, 2013a).
+
+When one trains a neural network, at some point in the training phase the evaluation of error seems to saturate, even if new examples are introduced. In particular Erhan et al. (2010) find that early examples have a much larger weight in the final solution. It looks like the learner is stuck in or near a local minimum. But since it is difficult to verify if this is near a true local minimum or simply an effect of strong ill-conditioning, we call such a “stuck” configuration an effective local minimum, whose definition depends not just on the optimization objective but also on the limitations of the optimization algorithm.
+
+Erhan et al. (2010) highlighted both the issue of effective local minima and a regularization effect when initializing a deep network with unsupervised pre-training. Interestingly, as the network gets deeper the difficulty due to effective local minima seems to be get more pronounced. That might be because of the number of effective local minima increases (more like an actual local minima issue), or maybe because the good ones are harder to reach (more like an ill-conditioning issue) and more work will be needed to clarify this question.
+
+As a result of Point 4 we hypothesize that it is very difficult for an individual’s brain to discover some higher level abstractions by chance only. As mentioned in the “Guided Learning Hypothesis” humans get hints from other humans and learn high-level concepts with the guidance of other humans3. Curriculum learning (Bengio et al., 2009a) and incremental learning (Solomonoff, 1989), are examples of this. This is done by properly choosing the sequence of examples seen by the learner, where simpler examples are introduced first and more complex examples shown when the learner is ready for them. One of the hypothesis on why curriculum works states that curriculum learning acts as a continuation method that allows one to discover a good minimum, by first finding a good minimum of a smoother error function. Recent experiments on human subjects also indicates that humans teach by using a curriculum strategy (Khan et al., 2011).
+
+Some parts of the human brain are known to have a hierarchical organization (i.e. visual cortex) consistent with the deep architecture studied in machine learning papers. As we go from the sensory level to higher levels of the visual cortex, we find higher level areas corresponding to more abstract concepts. This is consistent with the Deep Abstractions Hypothesis.
+
+Training neural networks and machine learning algorithms by decomposing the learning task into sub-tasks and exploiting prior information about the task is well-established and in fact constitutes the main approach to solving industrial problems with machine learning. The contribution of this paper is rather on rendering explicit the effective local minima issue and providing evidence on the type of problems for which this difficulty arises. This prior information and hints given to the learner can be viewed as inductive bias for a particular task, an important ingredient to obtain a good generalization error (Mitchell, 1980). An interesting earlier finding in that line of research was done with Explanation Based Neural Networks (EBNN) in which a neural network transfers knowledge across multiple learning tasks. An EBNN uses previously learned domain knowledge as an initialization or search bias (i.e. to constrain the learner in the parameter space) (O’Sullivan, 1996; Mitchell and Thrun, 1993).
+
+Another related work in machine learning is mainly focused on reinforcement learning algorithms, based on incorporating prior knowledge in terms of logical rules to the learning algorithm as a prior knowledge to speed up and bias learning (Kunapuli et al., 2010; Towell and Shavlik, 1994).
+
+As discussed in “Memes Divide and Conquer Hypothesis“ societies can be viewed as a distributed computational processing systems. In civilized societies knowledge is distributed across different individuals, this yields a space efficiency. Moreover computation, i.e. each individual can specialize on a particular task/topic, is also divided across the individuals in the society and hence this will yield a computational efficiency. Considering the limitations of the human brain, the whole processing can not be done just by a single agent in an efficient manner. A recent study in paleoantropology states that there is a substantial decline in endocranial volume of the brain in the last 30000 years Henneberg (1988). The volume of the brain shrunk to 1241 ml from 1502 ml (Henneberg and Steyn, 1993). One of the hypothesis on the reduction of the volume of skull claims that, decline in the volume of the brain might be related to the functional changes in brain that arose as a result of cultural development and emergence of societies given that this time period overlaps with the transition from hunter-gatherer lifestyle to agricultural societies.
+
+# 3. Experimental Setup
+
+Some tasks, which seem reasonably easy for humans to learn4, are nonetheless appearing almost impossible to learn for current generic state-of-art machine learning algorithms.
+
+Here we study more closely such a task, which becomes learnable if one provides hints to the learner about appropriate intermediate concepts. Interestingly, the task we used in our experiments is not only hard for deep neural networks but also for non-parametric machine learning algorithms such as SVM’s, boosting and decision trees.
+
+The result of the experiments for varying size of dataset with several off-the-shelf black box machine learning algorithms and some popular deep learning algorithms are provided in Table 1. The detailed explanations about the algorithms and the hyperparameters used for those algorithms are given in the Appendix Section 5.2. We also provide some explanations about the methodologies conducted for the experiments at Section 3.2.
+
+# 3.1 Pentomino Dataset
+
+In order to test our hypothesis, an artificial dataset for object recognition using 64 $\times$ 64 binary images is designed5. If the task is two tiered (i.e., with guidance provided), the task in the first part is to recognize and locate each Pentomino object class $_ 6$ in the image. The second part/final binary classification task is to figure out if all the Pentominos in the image are of the same shape class or not. If a neural network learned to detect the categories of each object at each location in an image, the remaining task becomes an XOR-like operation between the detected object categories. The types of Pentomino objects that is used for generating the dataset are as follows:
+
+![](images/71e82cdcb3f21cc5419b7df68b062571ca27a391ca97ba5965a878e221626d53.jpg)  
+Figure 1: Left (a): An example image from the dataset which has a different sprite type in it. Right (b): An example image from the dataset that has only one type of Pentomino object in it, but with different orientations and scales.
+
+Pentomino sprites N, P, F, Y, J, and Q, along with the Pentomino N2 sprite (mirror of “Pentomino N” sprite), the Pentomino F2 sprite (mirror of “Pentomino F” sprite), and the Pentomino Y2 sprite (mirror of “Pentomino Y” sprite).
+
+![](images/749d18b573d562563915d958a57284bf020d8df26bd28fc2618b1150862db437.jpg)  
+Figure 2: Different classes of Pentomino shapes used in our dataset.
+
+As shown in Figures 1(a) and 1(b), the synthesized images are fairly simple and do not have any texture. Foreground pixels are “1” and background pixels are “0”. Images of the training and test sets are generated iid. For notational convenience, assume that the domain of raw input images is $X$ , the set of sprites is $S$ , the set of intermediate object categories is $Y$ for each possible location in the image and the set of final binary task outcomes is $Z = \{ 0 , 1 \}$ . Two different types of rigid body transformation is performed: sprite rotation $r o t ( X , \gamma )$ where $\Gamma = \{ \gamma \colon ( \gamma = 9 0 \times \phi ) \wedge [ ( \phi \in \mathbb { N } ) , ( 0 \leq \phi \leq 3 ) ] \}$ and scaling $s c a l e ( X , \alpha )$ where $\alpha \in \{ 1 , 2 \}$ is the scaling factor. The data generating procedure is summarized below.
+
+Sprite transformations: Before placing the sprites in an empty image, for each image $x \in X$ , a value for $z \in Z$ is randomly sampled which is to have (or not) the same three sprite shapes in the image. Conditioned on the constraint given by $z$ , three sprites are randomly selected $s _ { i j }$ from $S$ without replacement. Using a uniform probability distribution over all possible scales, a scale is chosen and accordingly each sprite image is scaled. Then rotate each sprite is randomly rotated by a multiple of 90 degrees.
+
+Sprite placement: Upon completion of sprite transformations, a 64 $\times$ 64 uniform grid is generated which is divided into 8 $\times$ 8 blocks, each block being of size 8 $\times$ 8 pixels, and randomly select three different blocks from the 64=8 $\times$ 8 on the grid and place the transformed objects into different blocks (so they cannot overlap, by construction).
+
+Each sprite is centered in the block in which it is located. Thus there is no object translation inside the blocks. The only translation invariance is due to the location of the block inside the image.
+
+A Pentomino sprite is guaranteed to not overflow the block in which it is located, and there are no collisions or overlaps between sprites, making the task simpler. The largest possible Pentomino sprite can be fit into an 8 $\times$ 4 mask.
+
+# 3.2 Learning Algorithms Evaluated
+
+Initially the models are cross-validated by using 5-fold cross-validation. With 40,000 examples, this gives 32,000 examples for training and 8,000 examples for testing. For neural network algorithms, stochastic gradient descent (SGD) is used for training. The following standard learning algorithms were first evaluated: decision trees, SVMs with Gaussian kernel, ordinary fully-connected Multi-Layer Perceptrons, Random Forests, k-Nearest Neighbors, Convolutional Neural Networks, and Stacked Denoising Auto-Encoders with supervised fine-tuning. More details of the configurations and hyper-parameters for each of them are given in Appendix Section 5.2. The only better than chance results were obtained with variations of the Structured Multi-Layer Perceptron described below.
+
+# 3.2.1 Structured Multi-Layer Perceptron (SMLP)
+
+The neural network architecture that is used to solve this task is called the SMLP (Structured Multi-Layer Perceptron), a deep neural network with two parts as illustrated in Figure 5 and 7:
+
+The lower part, P1NN (Part 1 Neural Network, as it is called in the rest of the paper), has shared weights and local connectivity, with one identical MLP instance of the P1NN for each patch of the image, and typically an 11-element output vector per patch (unless otherwise noted). The idea is that these 11 outputs per patch could represent the detection of the sprite shape category (or the absence of sprite in the patch). The upper part, P2NN (Part 2 Neural Network) is a fully connected one hidden layer MLP that takes the concatenation of the outputs of all patch-wise P1NNs as input. Note that the first layer of P1NN is similar to a convolutional layer but where the stride equals the kernel size, so that windows do not overlap, i.e., P1NN can be decomposed into separate networks sharing the same parameters but applied on different patches of the input image, so that each network can actually be trained patch-wise in the case where a target is provided for the P1NN outputs. The P1NN output for patch $\mathbf { p _ { i } }$ which is extracted from the image $\mathbf { x }$ is computed as follows:
+
+$$
+f _ { \theta } ( \mathbf { p _ { i } } ) = g _ { 2 } ( V g _ { 1 } ( U \mathbf { p _ { i } } + \mathbf { b } ) + \mathbf { c } )
+$$
+
+where $\mathbf { p _ { i } } \in R ^ { d }$ is the input patch/receptive field extracted from location $i$ of a single image. $U \in R ^ { d _ { h } \times d }$ is the weight matrix for the first layer of P1NN and $ { \mathbf { b } } \in R _ { h } ^ { d }$ is the vector of biases for the first layer of P1NN. $g _ { 1 } ( \cdot )$ is the activation function of the first layer and $g _ { 2 } ( \cdot )$ is the activation function of the second layer. In many of the experiments, best results were obtained with $g _ { 1 } ( \cdot )$ a rectifying non-linearity (a.k.a. as RELU), which is $m a x ( 0 , \ X )$ (Jarrett et al., 2009b; Nair and Hinton, 2010; Glorot et al., 2011a; Krizhevsky et al., 2012). $V \in R ^ { d _ { h } \times d _ { o } }$ is the second layer’s weights matrix, such that and $\mathbf { c } \in R _ { d _ { o } }$ are the biases of the second layer of the P1NN, with $d _ { o }$ expected to be smaller than $d _ { h }$ .
+
+In this way, $g _ { 1 } ( U { \bf p } _ { \bf i } + { \bf b } )$ is an overcomplete representation of the input patch that can potentially represent all the possible Pentomino shapes for all factors of variations in the patch (rotation, scaling and Pentomino shape type). On the other hand, when trained with hints, $f _ { \boldsymbol \theta } ( \mathbf { p _ { i } } )$ is expected to be the lower dimensional representation of a Pentomino shape category invariant to scaling and rotation in the given patch.
+
+In the experiments with SMLP trained with hints (targets at the output of P1NN), the P1NN is expected to perform classification of each 8 $\times$ 8 non-overlapping patches of the original 64 $\times$ 64 input image without having any prior knowledge of whether that specific patch contains a Pentomino shape or not. P1NN in SMLP without hints just outputs the local activations for each patch, and gradients on $f _ { \boldsymbol \theta } ( \mathbf { p } _ { i } )$ are backpropagated from the upper layers. In both cases P1NN produces the input representation for the Part 2 Neural Net (P2NN). Thus the input representation of P2NN is the concatenated output of P1NN across all the 64 patch locations:
+
+$\mathbf { h _ { o } } = [ f _ { \theta } ( \mathbf { p _ { 0 } } ) , . . . , f _ { \theta } ( \mathbf { p _ { i } } ) , . . . , f _ { \theta } ( \mathbf { p _ { N } } ) ) ]$ where $N$ is the number of patches and the $h _ { o } \in R ^ { d _ { i } } , d _ { i } =$ $d _ { o } \times N$ . $\mathbf { h _ { 0 } }$ is the concatenated output of the P1NN at each patch.
+
+There is a standardization layer on top of the output of P1NN that centers the activations and performs divisive normalization by dividing by the standard deviation over a minibatch of the activations of that layer. We denote the standardization function $z ( \cdot )$ . Standardization makes use of the mean and standard deviation computed for each hidden unit such that each hidden unit of $\mathbf { h _ { 0 } }$ will have 0 activation and unit standard deviation on average over the minibatch. $X$ is the set of pentomino images in the minibatch, where $X \in R ^ { d _ { i n } \times N }$ is a matrix with $N$ images. $h _ { o } ^ { ( i ) } ( \mathbf { x _ { j } } )$ is the vector of activations of the $i$ -th hidden unit of hidden layer $h _ { o } ( \mathbf { x _ { j } } )$ for the $j$ -th example, with $x _ { j } \in X$ .
+
+$$
+\mu _ { h _ { o } ^ { ( i ) } } = \frac { 1 } { N } \sum _ { \mathbf { x _ { j } } \in X } h _ { o } ^ { ( i ) } ( \mathbf { x _ { j } } )
+$$
+
+$$
+\sigma _ { h _ { o } ^ { ( i ) } } = \sqrt { \frac { \sum _ { j } ^ { N } ( h _ { o } ^ { ( i ) } ( \mathbf { x _ { j } } ) - \mu _ { h _ { o } ^ { ( i ) } } ) ^ { 2 } } { N } + \epsilon }
+$$
+
+$$
+z ( h _ { o } ^ { ( i ) } ( \mathbf { x _ { j } } ) ) = \frac { h _ { o } ^ { ( i ) } ( \mathbf { x _ { j } } ) - \mu _ { h _ { o } ^ { ( i ) } } } { \operatorname* { m a x } ( \boldsymbol { \sigma } _ { h _ { o } ^ { ( i ) } } , \epsilon ) }
+$$
+
+where $\epsilon$ is a very small constant, that is used to prevent numerical underflows in the standard deviation. P1NN is trained on each 8 $\times$ 8 patches extracted from the image.
+
+$\mathbf { h _ { o } }$ is standardized for each training and test sample separately. Different values of $\epsilon$ were used for SMLP-hints and SMLP-nohints.
+
+The concatenated output of P1NN is fed as an input to the P2NN. P2NN is a feedforward MLP with a sigmoid output layer using a single RELU hidden layer. The task of P2NN is to perform a nonlinear logical operation on the representation provided at the output of P1NN.
+
+The SMLP-hints architecture exploits a hint about the presence and category of Pentomino objects, specifying a semantics for the P1NN outputs. P1NN is trained with the intermediate target $Y$ , specifying the type of Pentomino sprite shape present (if any) at each of the 64 patches (8 $\times$ 8 non-overlapping blocks) of the image. Because a possible answer at a given location can be “none of the object types” i.e., an empty patch, $y _ { p }$ (for patch $p$ ) can take one of the 11 possible values, 1 for rejection and the rest is for the Pentomino shape classes, illustrated in Figure 2:
+
+$$
+y _ { p } = { \left\{ \begin{array} { l l } { 0 } & { { \mathrm { i f ~ p a t c h ~ } } p { \mathrm { ~ i s ~ e m p t y } } } \\ { s \in S } & { { \mathrm { i f ~ t h e ~ p a t c h ~ } } p { \mathrm { ~ c o n t a i n s ~ a ~ P e n t o m i n o ~ s p r i t e ~ } } . } \end{array} \right. }
+$$
+
+A similar task has been studied by Fleuret et al. (2011) (at SI appendix Problem 17), who compared the performance of humans vs computers.
+
+The SMLP-hints architecture takes advantage of dividing the task into two subtasks during training with prior information about intermediate-level relevant factors. Because the sum of the training losses decomposes into the loss on each patch, the P1NN can be pre-trained patchwise. Each patch-specific component of the P1NN is a fully connected MLP with 8 $\times$ 8 inputs and 11 outputs with a softmax output layer. SMLP-hints uses the the standardization given in Equation 3 but with $\epsilon = 0$ .
+
+The standardization is a crucial step for training the SMLP on the Pentomino dataset, and yields much sparser outputs, as seen on Figures 3 and 4. If the standardization is not used, even SMLP-hints could not solve the Pentomino task. In general, the standardization step dampens the small activations and augments larger ones(reducing the noise). Centering the activations of each feature detector in a neural network has been studied in (Raiko et al., 2012) and (Vatanen et al., 2013). They proposed that transforming the outputs of each hidden neuron in a multi-layer perceptron network to have zero output and zero slope on average makes first order optimization methods closer to the second order techniques.
+
+By default, the SMLP uses rectifier hidden units as activation function, we found a significant boost by using rectification compared to hyperbolic tangent and sigmoid activation functions. The P1NN has a highly overcomplete architecture with 1024 hidden units per patch, and L1 and L2 weight decay regularization coefficients on the weights (not the biases) are respectively 1e-6 and 1e-5. The learning rate for the P1NN is 0.75. 1 training epoch was enough for the P1NN to learn the features of Pentomino shapes perfectly on the 40000 training examples. The P2NN has 2048 hidden units. L1 and L2 penalty coefficients for the P2NN are 1e-6, and the learning rate is 0.1. These were selected by trial and error based on validation set error. Both P1NN (for each patch) and P2NN are fully-connected neural networks, even though P1NN globally is a special kind of convolutional neural network.
+
+Filters of the first layer of SMLP are shown in Figure 6. These are the examples of the filters obtained with the SLMP-hints trained with 40k examples, whose results are given in Table 1. Those filters look very noisy but they work perfectly on the Pentomino task.
+
+# 3.2.3 Deep and Structured Supervised MLP without Hints (SMLP-nohints)
+
+SMLP-nohints uses the same connectivity pattern (and deep architecture) that is also used in the SMLP-hints architecture, but without using the intermediate targets ( $Y$ ). It directly predicts the final outcome of the task ( $Z$ ), using the same number of hidden units, the same connectivity and the same activation function for the hidden units as SMLP-hints. 120 hyperparameter values have been evaluated by randomly selecting the number of hidden units from [64, 128, 256, 512, 1024, 1200, 2048] and randomly sampling 20 learning rates uniformly in the log-domain within the interval of [0.008, 0.8]. Two fully connected hidden layers with 1024 hidden units (same as P1NN) per patch is used and 2048 (same as P2NN) for the last hidden layer, with twenty training epochs. For this network the best results are obtained with a learning rate of 0.05.7
+
+![](images/d87ab9eb183661d071c49741a7f9d8e608e824481641c083107a25b584f0a0c3.jpg)  
+Figure 3: Bar chart of concatenated softmax output activations $\mathbf { h _ { o } }$ of P1NN ( $1 1 \times 6 4 = 7 0 4$ outputs) in SMLP-hints before standardization, for a selected example. There are very large spikes at each location for one of the possible 11 outcome (1 of K representation).
+
+![](images/5f3c5a48f8967c072a2f38fcd9698475b5947b72531e1b3883ad6b9c48be44be.jpg)  
+Figure 4: Softmax output activations $\mathbf { h _ { 0 } }$ of P1NN at SMLP-hints before standardization. There are positive spiked outputs at the locations where there is a Pentomino shape. Positive and negative spikes arise because most of the outputs are near an average value. Activations are higher at the locations where there is a pentomino shape.
+
+![](images/9ebe69810559f75a29f3a9af57af1c7c61dc4b1396c785410e22be35c006c129.jpg)  
+Figure 5: Structured MLP architecture, used with hints (trained in two phases, first P1NN, bottom two layers, then P2NN, top two layers). In SMLP-hints, P1NN is trained on each 8x8 patch extracted from the image and the softmax output probabilities of all 64 patches are concatenated into a 64 $\times$ 11 vector that forms the input of P2NN. Only $U$ and $V$ are learned in the P1NN and its output on each patch is fed into P2NN. The first level and the second level neural networks are trained separately, not jointly.
+
+![](images/b997273adc4d15d16c3d878b05ebc44601f6c6791be80387aad4c4b3fed338ac.jpg)  
+Figure 6: Filters of Structured MLP architecture, trained with hints on 40k examples.
+
+![](images/b96bde0037ffe063251bb00c0b4a1cac06602f9895d91d2c93da312bcc42a849.jpg)  
+Figure 7: Structured MLP architecture, used without hints (SMLP-nohints). It is the same architecture as SMLP-hints (Figure 5) but with both parts (P1NN and P2NN) trained jointly with respect to the final binary classification task.
+
+We chose to experiment with various SMLP-nohint architectures and optimization procedures, trying unsuccessfully to achieve as good results with SMLP-nohint as with SMLP-hints.
+
+Rectifier Non-Linearity A rectifier nonlinearity is used for the activations of MLP hidden layers. We observed that using piecewise linear nonlinearity activation function such as the rectifier can make the optimization more tractable.
+
+![](images/581bec2237cbdeef0543fe261bd206a299def4541bcd4fbf4c7647cdc46992b5.jpg)  
+Figure 8: First layer filters learned by the Structured MLP architecture, trained without using hints on 447600 examples with online SGD and a sigmoid intermediate layer activation.
+
+Intermediate Layer The output of the P1NN is considered as an intermediate layer of the SMLP. For the SMLP-hints, only softmax output activations have been tried at the intermediate layer, and that sufficed to learn the task. Since things did not work nearly as well with the SMLP-nohints, several different activation functions have been tried: softmax $( \cdot )$ , $\operatorname { t a n h } ( { \cdot } )$ , sigmoid $( \cdot )$ and linear activation functions.
+
+Standardization Layer Normalization at the last layer of the convolutional neural networks has been used occasionaly to encourage the competition between the hidden units. (Jarrett et al., 2009a) used a local contrast normalization layer in their architecture which performs subtractive and divisive normalization. A local contrast normalization layer enforces a local competition between adjacent features in the feature map and between features at the same spatial location in different feature maps. Similarly (Krizhevsky et al., 2012) observed that using a local response layer that enjoys the benefit of using local normalization scheme aids generalization.
+
+Standardization has been observed to be crucial for both SMLP trained with or without hints. In both SMLP-hints and SMLP-nohints experiments, the neural network was not able to generalize or even learn the training set without using standardization in the SMLP intermediate layer, doing just chance performance. More specifically, in the SMLP-nohints architecture, standardization is part of the computational graph, hence the gradients are being backpropagated through it. The mean and the standard deviation is computed for each hidden unit separately at the intermediate layer as in Equation 4. But in order to prevent numerical underflows or overflows during the backpropagation we have used $\epsilon = 1 e - 8$ (Equation 3).
+
+The benefit of having sparse activations may be specifically important for the ill-conditioned problems, for the following reasons. When a hidden unit is “off”, its gradient (the derivative of the loss with respect to its output) is usually close to 0 as well, as seen here. That means that all off-diagonal second derivatives involving that hidden unit (e.g. its input weights) are also near 0. This is basically like removing some columns and rows from the Hessian matrix associated with a particular example. It has been observed that the condition number of the Hessian matrix (specifically, its largest eigenvalue) increases as the size of the network increases (Dauphin and Bengio, 2013), making training considerably slower and inefficient (Dauphin and Bengio, 2013). Hence one would expect that as sparsity of the gradients (obtained because of sparsity of the activations) increases, training would become more efficient, as if we were training a smaller sub-network for each example, with shared weights across examples, as in dropouts (Hinton et al., 2012).
+
+In Figure 9, the activation of each hidden unit in a bar chart is shown: the effect of standardization is significant, making the activations sparser.
+
+![](images/53a71e628d0acba4ebdbaeb489602e0c7008b770eabfe04a0c2e1011bfec7c52.jpg)  
+Figure 9: Activations of the intermediate-level hidden units of an SLMP-nohints for a particular examples (x-axis: hidden unit number, y-axis: activation value). Left (a): before standardization. Right (b): after standardization.
+
+In Figure 10, one can see the activation histogram of the SMLP-nohints intermediate layer, showing the distribution of activation values, before and after standardization. Again the sparsifying effect of standardization is very apparent.
+
+![](images/5becb1fae51ccfd23e22af606adf55867016df780c4e313319f4256415a851f2.jpg)  
+Figure 10: Distribution histogram of activation values of SMLP-nohints intermediate layer. Left (a): before standardization. Right (b): after standardization.
+
+In Figures 10 and 9, the intermediate level activations of SMLP-nohints are shown before and after standardization. These are for the same SMLP-nohints architecture whose results are presented on Table 1. For that same SMLP, the Adadelta (Zeiler, 2012) adaptive learning rate scheme has been used, with 512 hidden units for the hidden layer of P1NN and rectifier activation function. For the output of the P1NN, 11 sigmoidal units have been used while P2NN had 1200 hidden units with rectifier activation function. The output nonlinearity of the P2NN is a sigmoid and the training objective is the binary crossentropy.
+
+Adaptive Learning Rates We have experimented with several different adaptive learning rate algorithms. We tried rmsprop 8, Adadelta (Zeiler, 2012), Adagrad (Duchi et al., 2010) and a linearly $\left( 1 / \mathrm { t } \right)$ decaying learning rate (Bengio, 2013b). For the SMLP-nohints with sigmoid activation function we have found Adadelta(Zeiler, 2012) converging faster to an effective local minima and usually yielding better generalization error compared to the others.
+
+# 3.2.4 Deep and Structured MLP with Unsupervised Pre-Training
+
+Several experiments have been conducted using an architecture similar to the SMLP-nohints, but by using unsupervised pre-training of P1NN, with Denoising Auto-Encoder (DAE) and/or Contractive Auto-Encoders (CAE). Supervised fine-tuning proceeds as in the deep and structured MLP without hints. Because an unsupervised learner may not focus the representation just on the shapes, a larger number of intermediate-level units at the output of P1NN has been explored: previous work on unsupervised pre-training generally found that larger hidden layers were optimal when using unsupervised pre-training, because not all unsupervised features will be relevant to the task at hand. Instead of limiting to 11 units per patch, we experimented with networks with up to 20 hidden (i.e., code) units per patch in the second-layer patch-wise auto-encoder.
+
+In Appendix 5.1 we also provided the result of some experiments with binary-binary RBMs trained on 8 $\times$ 8 patches from the 40k training dataset.
+
+In unsupervised pretraining experiments in this paper, both contractive auto-encoder (CAE) with sigmoid nonlinearity and binary cross entropy cost function and denoising auto-encoder (DAE) have been used. In the second layer, experiments were performed with a DAE with rectifier hidden units utilizing L1 sparsity and weight decay on the weights of the auto-encoder. Greedy layerwise unsupervised training procedure is used to train the deep auto-encoder architecture (Bengio et al., 2007). In unsupervised pretraining experiments, tied weights have been used. Different combinations of CAE and DAE for unsupervised pretraining have been tested, but none of the configurations tested managed to learn the Pentomino task, as shown in Table 1.
+
+# 3.3 Experiments with 1 of $\mathbf { K }$ representation
+
+To explore the effect of changing the complexity of the input representation on the difficulty of the task, a set of experiments have been designed with symbolic representations of the information in each patch. In all cases an empty patch is represented with a 0 vector. These representation can be seen as an alternative input for a P2NN-like network, i.e., they were fed as input to an MLP or another black-box classifier.
+
+The following four experiments have been conducted, each one using one using a different input representation for each patch:
+
+<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=2>20kdataset</td><td rowspan=1 colspan=2>40kdataset</td><td rowspan=1 colspan=2>80kdataset</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>TrainingError</td><td rowspan=1 colspan=1>TestError</td><td rowspan=1 colspan=1>TrainingError</td><td rowspan=1 colspan=1>TestError</td><td rowspan=1 colspan=1>TrainingError</td><td rowspan=1 colspan=1>TestError</td></tr><tr><td rowspan=1 colspan=1>SVMRBF</td><td rowspan=1 colspan=1>26.2</td><td rowspan=1 colspan=1>50.2</td><td rowspan=1 colspan=1>28.2</td><td rowspan=1 colspan=1>50.2</td><td rowspan=1 colspan=1>30.2</td><td rowspan=1 colspan=1>49.6</td></tr><tr><td rowspan=1 colspan=1>KNearest Neighbors</td><td rowspan=1 colspan=1>24.7</td><td rowspan=1 colspan=1>50.0</td><td rowspan=1 colspan=1>25.3</td><td rowspan=1 colspan=1>49.5</td><td rowspan=1 colspan=1>25.6</td><td rowspan=1 colspan=1>49.0</td></tr><tr><td rowspan=1 colspan=1>Decision Tree</td><td rowspan=1 colspan=1>5.8</td><td rowspan=1 colspan=1>48.6</td><td rowspan=1 colspan=1>6.3</td><td rowspan=1 colspan=1>49.4</td><td rowspan=1 colspan=1>6.9</td><td rowspan=1 colspan=1>49.9</td></tr><tr><td rowspan=1 colspan=1>Randomized Trees</td><td rowspan=1 colspan=1>3.2</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>3.4</td><td rowspan=1 colspan=1>50.5</td><td rowspan=1 colspan=1>3.5</td><td rowspan=1 colspan=1>49.1</td></tr><tr><td rowspan=1 colspan=1>MLP</td><td rowspan=1 colspan=1>26.5</td><td rowspan=1 colspan=1>49.3</td><td rowspan=1 colspan=1>33.2</td><td rowspan=1 colspan=1>49.9</td><td rowspan=1 colspan=1>27.2</td><td rowspan=1 colspan=1>50.1</td></tr><tr><td rowspan=1 colspan=1>Convnet/Lenet5</td><td rowspan=1 colspan=1>50.6</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>49.4</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>50.2</td><td rowspan=1 colspan=1>49.8</td></tr><tr><td rowspan=1 colspan=1>Maxout Convnet</td><td rowspan=1 colspan=1>14.5</td><td rowspan=1 colspan=1>49.5</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>50.1</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>44.6</td></tr><tr><td rowspan=1 colspan=1>2 layer sDA</td><td rowspan=1 colspan=1>49.4</td><td rowspan=1 colspan=1>50.3</td><td rowspan=1 colspan=1>50.2</td><td rowspan=1 colspan=1>50.3</td><td rowspan=1 colspan=1>49.7</td><td rowspan=1 colspan=1>50.3</td></tr><tr><td rowspan=1 colspan=1>Struct.Supervised MLPw/ohints</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>48.6</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>36.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>12.4</td></tr><tr><td rowspan=1 colspan=1>Struct. MLP+CAE Supervised Finetuning</td><td rowspan=1 colspan=1>50.5</td><td rowspan=1 colspan=1>49.7</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>49.7</td><td rowspan=1 colspan=1>50.3</td><td rowspan=1 colspan=1>49.7</td></tr><tr><td rowspan=1 colspan=1>Struct.MLP+CAE+DAE,Supervised Finetuning</td><td rowspan=1 colspan=1>49.1</td><td rowspan=1 colspan=1>49.7</td><td rowspan=1 colspan=1>49.4</td><td rowspan=1 colspan=1>49.7</td><td rowspan=1 colspan=1>50.1</td><td rowspan=1 colspan=1>49.7</td></tr><tr><td rowspan=1 colspan=1>Struct.MLP+DAE+DAE, Supervised Finetuning</td><td rowspan=1 colspan=1>49.5</td><td rowspan=1 colspan=1>50.3</td><td rowspan=1 colspan=1>49.7</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>50.3</td><td rowspan=1 colspan=1>49.7</td></tr><tr><td rowspan=1 colspan=1>Struct.MLPwith Hints</td><td rowspan=1 colspan=1>0.21</td><td rowspan=1 colspan=1>30.7</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3.1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.01</td></tr></table>
+
+Table 1: The error percentages with different learning algorithms on Pentomino dataset with different number of training examples.
+
+Experiment 1-Onehot representation without transformations: In this experiment several trials have been done with a 10-input one-hot vector per patch. Each input corresponds to an object category given in clear, i.e., the ideal input for P2NN if a supervised P1NN perfectly did its job.
+
+Experiment 2-Disentangled representations: In this experiment, we did trials with 16 binary inputs per patch, 10 one-hot bits for representing each object category, 4 for rotations and 2 for scaling, i.e., the whole information about the input is given, but it is perfectly disentangled. This would be the ideal input for P2NN if an unsupervised P1NN perfectly did its job.
+
+Experiment 3-Onehot representation with transformations: For each of the ten object types there are 8 = 4 $\times$ 2 possible transformations. Two objects in two different patches are the considered “the same” (for the final task) if their category is the same regardless of the transformations. The one-hot representation of a patch corresponds to the crossproduct between the 10 object shape classes and the 4 $\times$ 2 transformations, i.e., one out of 80=10 $\times$ 4 × 2 possibilities represented in an 80-bit one-hot vector. This also contains all the information about the input image patch, but spread out in a kind of non-parametric and non-informative (not disentangled) way, like a perfect memory-based unsupervised learner (like clustering) could produce. Nevertheless, the shape class would be easier to read out from this representation than from the image representation (it would be an OR over 8 of the bits).
+
+Experiment 4-Onehot representation with 80 choices: This representation has the same 1 of 80 one-hot representation per patch but the target task is defined differently. Two objects in two different patches are considered the same iff they have exactly the same 80-bit onehot representation (i.e., are of the same object category with the same transformation applied).
+
+The first experiment is a sanity check. It was conducted with single hidden-layered MLP’s with rectifier and tanh nonlinearity, and the task was learned perfectly (0 error on both training and test dataset) with very few training epochs.
+
+![](images/3af2ef059ca07fc1f0bcbc9fd3889b27c1f44aa17099718947475444a3f21a80.jpg)  
+Figure 11: Tanh MLP training curves. Left (a): The training and test errors of Experiment 3 over 800 training epochs with 100k training examples using Tanh MLP. Right (b):The training and test errors of Experiment 4 over 700 training epochs with 100k training examples using Tanh MLP.
+
+![](images/13975ebf0c531963c11f94761dbb9fdf88275f111ad20f286f7c597dfff45ea6.jpg)  
+(b) Training and Test Errors for Experiment 3
+
+The results of Experiment 2 are given in Table 2. To improve results, we experimented with the Maxout non-linearity in a feedforward MLP (Goodfellow et al., 2013) with two hidden layers. Unlike the typical Maxout network mentioned in the original paper, regularizers have been deliberately avoided in order to focus on the optimization issue, i.e: no weight decay, norm constraint on the weights, or dropout. Although learning from a disentangled representation is more difficult than learning from perfect object detectors, it is feasible with some architectures such as the Maxout network. Note that this representation is the kind of representation that one could hope an unsupervised learning algorithm could discover, at best, as argued in Bengio et al. (2012).
+
+The only results obtained on the validation set for Experiment 3 and Experiment 4 are shown respectively in Table 3 and Table 4. In these experiments a tanh MLP with two hidden layers have been tested with the same hyperparameters. In experiment 3 the complexity of the problem comes from the transformations (8=4 $\times$ 2) and the number of object types.
+
+But in experiment 4, the only source of complexity of the task comes from the number of different object types. These results are in between the complete failure and complete success observed with other experiments, suggesting that the task could become solvable with better training or more training examples. Figure 11 illustrates the progress of training a tanh MLP, on both the training and test error, for Experiments 3 and 4. Clearly, something has been learned, but the task is not nailed yet. On experiment 3 for both maxout and tanh the maxout there was a long plateau where the training error and objective stays almost same. Maxout did just chance on the experiment for about 120 iterations on the training and the test set. But after 120th iteration the training and test error started decline and eventually it was able to solve the task. Moreover as seen from the curves in Figure 11(a) and 11(b), the training and test error curves are almost the same for both tasks. This implies that for onehot inputs, whether you increase the number of possible transformations for each object or the number of
+
+Table 2: Performance of different learning algorithms on disentangled representation in Experiment 2.   
+
+<table><tr><td>Learning Algorithm</td><td>Training Error</td><td>Test Error</td></tr><tr><td>SVM</td><td>0.0</td><td>35.6</td></tr><tr><td>RANDOM FORESTS</td><td>1.29</td><td>40.475</td></tr><tr><td>TANH MLP</td><td>0.0</td><td>0.0</td></tr><tr><td>MAXOUT MLP</td><td>0.0</td><td>0.0</td></tr></table>
+
+<table><tr><td>Learning Algorithm</td><td>Training Error</td><td>Test Error</td></tr><tr><td>SVM</td><td>11.212</td><td>32.37</td></tr><tr><td>RANDOM FORESTS</td><td>24.839</td><td>48.915</td></tr><tr><td>TANH MLP</td><td>0.0</td><td>22.475</td></tr><tr><td>MAXOUT MLP</td><td>0.0</td><td>0.0</td></tr></table>
+
+Table 3: Performance of different learning algorithms using a dataset with onehot vector and 80 inputs as discussed for Experiment 3.
+
+object categories, as soon as the number of possible configurations is same, the complexity of the problem is almost the same for the MLP.
+
+# 3.4 Does the Effect Persist with Larger Training Set Sizes?
+
+The results shown in this section indicate that the problem in the Pentomino task clearly is not just a regularization problem, but rather basically hinges on an optimization problem. Otherwise, we would expect test error to decrease as the number of training examples increases. This is shown first by studying the online case and then by studying the ordinary training case with a fixed size training set but considering increasing training set sizes. In the online minibatch setting, parameter updates are performed as follows:
+
+$$
+\theta _ { t + 1 } = \theta _ { t } - \Delta _ { \theta _ { t } }
+$$
+
+$$
+\Delta _ { \theta _ { t } } = \epsilon \frac { \sum _ { i } ^ { N } \nabla _ { \theta _ { t } } L ( x _ { t } , \theta _ { t } ) } { N }
+$$
+
+where $L ( x _ { t } , \theta _ { t } )$ is the loss incurred on example $x _ { t }$ with parameters $\theta _ { t }$ , where $t \in \mathcal { Z } ^ { + }$ and $\epsilon$ is the learning rate.
+
+Ordinary batch algorithms converge linearly to the optimum $\theta ^ { * }$ , however the noisy gradient estimates in the online SGD will cause parameter $\theta$ to fluctuate near the local optima. However, online SGD directly optimizes the expected risk, because the examples are drawn iid from the ground-truth distribution (Bottou, 2010). Thus:
+
+$$
+L _ { \infty } = E [ L ( x , \theta ) ] = \int _ { x } L ( x , \theta ) p ( x ) d _ { x }
+$$
+
+<table><tr><td rowspan=1 colspan=6>Learning Algorithm</td><td rowspan=1 colspan=1>Learning Algorithm</td><td rowspan=1 colspan=1>Training Error</td></tr><tr><td rowspan=5 colspan=6>SVMRANDOM FORESTSTANH MLP</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4.346</td></tr><tr><td rowspan=2 colspan=2>STS</td><td></td><td></td></tr><tr><td rowspan=1 colspan=2>TS</td><td rowspan=2 colspan=1>23.4560</td><td rowspan=2 colspan=1>47.34525.8</td></tr><tr><td rowspan=2 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1></td></tr></table>
+
+Table 4: Performance of different algorithms using a dataset with onehot vector and 80 binary inputs as discussed in Experiment 4.
+
+where $L _ { \infty }$ is the generalization error. Therefore online SGD is trying to minimize the expected risk with noisy updates. Those noisy updates have the effect of regularizer:
+
+$$
+\Delta _ { \theta _ { t } } = \epsilon \frac { \sum _ { i } ^ { N } \nabla _ { \theta _ { t } } L ( x _ { t } , \theta _ { t } ) } { N } = \epsilon \nabla _ { \theta _ { t } } L ( x , \theta _ { t } ) + \epsilon \xi _ { t }
+$$
+
+where $\nabla _ { \theta _ { t } } L ( x , \theta _ { t } )$ is the true gradient and $\xi _ { t }$ is the zero-mean stochastic gradient “noise” due to computing the gradient over a finite-size minibatch sample.
+
+We would like to know if the problem with the Pentomino dataset is more a regularization or an optimization problem. An SMLP-nohints model was trained by online SGD with the randomly generated online Pentomino stream. The learning rate was adaptive, with the Adadelta procedure (Zeiler, 2012) on minibatches of 100 examples. In the online SGD experiments, two SMLP-nohints that is trained with and without standardization at the intermediate layer with exactly the same hyperparameters are tested. The SMLP-nohints P1NN patch-wise submodel has 2048 hidden units and the SMLP intermediate layer has $1 1 5 2 = 6 4 \times 1 8$ hidden units. The nonlinearity that is used for the intermediate layer is the sigmoid. P2NN has 2048 hidden units.
+
+SMLP-nohints has been trained either with or without standardization on top of the output units of the P1NN. The experiments illustrated in Figures 12 and 13 are with the same SMLP without hints architecture for which results are given in Table 1. In those graphs only the results for the training on the randomly generated 545400 Pentomino samples have been presented. As shown in the plots SMLP-nohints was not able to generalize without standardization. Although without standardization the training loss seems to decrease initially, it eventually gets stuck in a plateau where training loss doesn’t change much.
+
+Training of SMLP-nohints online minibatch SGD is performed using standardization in the intermediate layer and Adadelta learning rate adaptation, on 1046000 training examples from the randomly generated Pentomino stream. At the end of the training, test error is down to $2 7 . 5 \%$ , which is much better than chance but from from the score obtained with SMLP-hints of near 0 error.
+
+In another SMLP-nohints experiment without standardization the model is trained with the 1580000 Pentomino examples using online minibatch SGD. P1NN has 2048 hidden units and 16 sigmoidal outputs per patch. for the P1NN hidden layer. P2NN has 1024 hidden units for the hidden layer. Adadelta is used to adapt the learning rate. At the end of training this SMLP, the test error remained stuck, at $5 0 . 1 \%$ .
+
+![](images/3f7ccb37d7f821d7fd3fe0817d021453f0641ef6d4ad91b516d48bc5672bebd0.jpg)  
+Figure 12: Test errors of SMLP-nohints with and without standardization in the intermediate layer. Sigmoid as an intermediate layer activation has been used. Each tick (batch no) in the x-axis represents 400 examples.
+
+![](images/9594e46b7cabd7e897fbe1f718336a57f2d76240e86c954b9617116eb6fbf9af.jpg)  
+Figure 13: Training errors of SMLP-nohints with and without standardization in the intermediate layer. Sigmoid nonlinearity has been used as an intermediate layer activation function. The x-axis is in units of blocks of 400 examples in the training set.
+
+Here we consider the effect of training different learners with different numbers of training examples. For the experimental results shown in Table 1, 3 training set sizes (20k, 40k and 80k examples) had been used. Each dataset was generated with different random seeds (so they do not overlap). Figure 14 also shows the error bars for an ordinary MLP with three hidden layers, for a larger range of training set sizes, between 40k and 320k examples. The number of training epochs is 8 (more did not help), and there are three hidden layers with 2048 feature detectors. The learning rate we used in our experiments is 0.01. The activation function of the MLP is a tanh nonlinearity, while the L1, L2 penalty coefficients are both 1e-6.
+
+Table 1 shows that, without guiding hints, none of the state-of-art learning algorithms could perform noticeably better than a random predictor on the test set. This shows the importance of intermediate hints introduced in the SMLP. The decision trees and SVMs can overfit the training set but they could not generalize on the test set. Note that the numbers reported in the table are for hyper-parameters selected based on validation set error, hence lower training errors are possible if avoiding all regularization and taking large enough models. On the training set, the MLP with two large hidden layers (several thousands) could reach nearly $0 \%$ training error, but still did not manage to achieve good test error.
+
+In the experiment results shown in Figure 14, we evaluate the impact of adding more training data for the fully-connected MLP. As mentioned before for these experiments we have used a MLP with three hidden layers where each layer has 2048 hidden units. The $\operatorname { t a n h } ( { \cdot } )$ activation function is used with 0.05 learning rate and minibatches of size 200.
+
+As can be seen from the figure, adding more training examples did not help either training or test error (both are near $5 0 \%$ , with training error slightly lower and test error slightly higher), reinforcing the hypothesis that the difficult encountered is one of optimization, not of regularization.
+
+![](images/ccde6c13d809edbf1682877d716b706ee4cfc24b70e36a66eff3c8ddf8eef0fe.jpg)  
+Figure 14: Training and test error bar charts for a regular MLP with 3 hidden layers. There is no significant improvement on the generalization error of the MLP as the new training examples are introduced.
+
+# 3.5 Experiments on Effect of Initializing with Hints
+
+Initialization of the parameters in a neural network can have a big impact on the learning and generalization (Glorot and Bengio, 2010). Previously Erhan et al. (2010) showed that initializing the parameters of a neural network with unsupervised pretraining guides the learning towards basins of attraction of local minima that provides better generalization from the training dataset. In this section we analyze the effect of initializing the SMLP with hints and then continuing without hints at the rest of the training. For experimental analysis of hints based initialization, SMLP is trained for 1 training epoch using the hints and for 60 epochs it is trained without hints on the 40k examples training set. We also compared the same architecture with the same hyperparameters, against to SMLP-nohints trained for 61 iterations on the same dataset. After one iteration of hint-based training SMLP obtained 9% training error and 39% test error. Following the hint based training, SMLP is trained without hints for 60 epochs, but at epoch 18, it already got 0% training and 0% test error. The hyperparameters for this experiment and the experiment that the results shown for the SMLP-hints in Table 1 are the same. The test results for initialization with and without hints are shown on Figure 15. This figure suggests that initializing with hints can give the same generalization performance but training takes longer.
+
+![](images/59b8f539b86b7592ebb7ac172640d734a24c961332be9752c35c196bff61abff.jpg)  
+Figure 15: Plots showing the test error of SMLP with random initialization vs initializing with hint based training.
+
+# 3.5.1 Further Experiments on Optimization for Pentomino Dataset
+
+With extensive hyperparameter optimization and using standardization in the intermediate level of the SMLP with softmax nonlinearity, SMLP-nohints was able to get $5 . 3 \%$ training and
+
+6.7% test error on the 80k Pentomino training dataset. We used the 2050 hidden units for the hidden layer of P1NN and 11 softmax output per patch. For the P2NN, we used 1024 hidden units with sigmoid and learning rate 0.1 without using any adaptive learning rate method. This SMLP uses a rectifier nonlinearity for hidden layers of both P1NN and P2NN. Considering that architecture uses softmax as the intermediate activation function of SMLP-nohints. It is very likely that P1NN is trying to learn the presence of specific Pentomino shape in a given patch. This architecture has a very large capacity in the P1NN, that probably provides it enough capacity to learn the presence of Pentomino shapes at each patch effortlessly.
+
+An MLP with 2 hidden layers, each 1024 rectifier units, was trained using LBFGS (the implementation from the scipy.optimize library) on 40k training examples, with gradients computed on batches of 10000 examples at each iteration. However, after convergence of training, the MLP was still doing chance on the test dataset.
+
+We also observed that using linear units for the intermediate layer yields better generalization error without standardization compared to using activation functions such as sigmoid, tanh and RELU for the intermediate layer. SMLP-nohints was able to get 25% generalization error with linear units without standardization whereas all the other activation functions that has been tested failed to generalize with the same number of training iterations without standardization and hints. This suggests that using non-linear intermediate-level activation functions without standardization introduces an optimization difficulty for the SMLP-nohints, maybe because the intermediate level acts like a bottleneck in this architecture.
+
+# 4. Conclusion and Discussion
+
+In this paper we have shown an example of task which seems almost impossible to solve by standard black-box machine learning algorithms, but can be almost perfectly solved when one encourages a semantics for the intermediate-level representation that is guided by prior knowledge. The task has the particularity that it is defined by the composition of two nonlinear sub-tasks (object detection on one hand, and a non-linear logical operation similar to XOR on the other hand).
+
+What is interesting is that in the case of the neural network, we can compare two networks with exactly the same architecture but a different pre-training, one of which uses the known intermediate concepts to teach an intermediate representation to the network. With enough capacity and training time they can overfit but did not not capture the essence of the task, as seen by test set performance.
+
+We know that a structured deep network can learn the task, if it is initialized in the right place, and do it from very few training examples. Furthermore we have shown that if one pre-trains SMLP with hints for only one epoch, it can nail the task. But the exactly same architecture which started training from random initialization, failed to generalize.
+
+Consider the fact that even SMLP-nohints with standardization after being trained using online SGD on 1046000 generated examples and still gets $2 7 . 5 \%$ test error. This is an indication that the problem is not a regularization problem but possibly an inability to find a good effective local minima of generalization error.
+
+What we hypothesize is that for most initializations and architectures (in particular the fully-connected ones), although it is possible to find a good effective local minimum of training error when enough capacity is provided, it is difficult (without the proper initialization) to find a good local minimum of generalization error. On the other hand, when the network architecture is constrained enough but still allows it to represent a good solution (such as the structured MLP of our experiments), it seems that the optimization problem can still be difficult and even training error remains stuck high if the standardization isn’t used. Standardization obviously makes the training objective of the SMLP easier to optimize and helps it to find at least a better effective local minimum of training error. This finding suggests that by using specific architectural constraints and sometimes domain specific knowledge about the problem, one can alleviate the optimization difficulty that generic neural network architectures face.
+
+It could be that the combination of the network architecture and training procedure produces a training dynamics that tends to yield into these minima that are poor from the point of view of generalization error, even when they manage to nail training error by providing enough capacity. Of course, as the number of examples increases, we would expect this discrepancy to decrease, but then the optimization problem could still make the task unfeasible in practice. Note however that our preliminary experiments with increasing the training set size (8-fold) for MLPs did not reveal signs of potential improvements in test error yet, as shown in Figure 14. Even using online training on 545400 Pentomino examples, the SMLP-nohints architecture was still doing far from perfect in terms of generalization error (Figure 12).
+
+These findings bring supporting evidence to the “Guided Learning Hypothesis” and “Deeper Harder Hypothesis” from Bengio (2013a): higher level abstractions, which are expressed by composing simpler concepts, are more difficult to learn (with the learner often getting in an effective local minimum ), but that difficulty can be overcome if another agent provides hints of the importance of learning other, intermediate-level abstractions which are relevant to the task.
+
+Many interesting questions remain open. Would a network without any guiding hint eventually find the solution with a enough training time and/or with alternate parametrizations? To what extent is ill-conditioning a core issue? The results with LBFGS were disappointing but changes in the architectures (such as standardization of the intermediate level) seem to make training much easier. Clearly, one can reach good solutions from an appropriate initialization, pointing in the direction of an issue with local minima, but it may be that good solutions are also reachable from other initializations, albeit going through a tortuous ill-conditioned path in parameter space. Why did our attempts at learning the intermediate concepts in an unsupervised way fail? Are these results specific to the task we are testing or a limitation of the unsupervised feature learning algorithm tested? Trying with many more unsupervised variants and exploring explanatory hypotheses for the observed failures could help us answer that. Finally, and most ambitious, can we solve these kinds of problems if we allow a community of learners to collaborate and collectively discover and combine partial solutions in order to obtain solutions to more abstract tasks like the one presented here? Indeed, we would like to discover learning algorithms that can solve such tasks without the use of prior knowledge as specific and strong as the one used in the SMLP here. These experiments could be inspired by and inform us about potential mechanisms for collective learning through cultural evolutions in human societies.
+
+# Acknowledgments
+
+We would like to thank to the ICLR 2013 reviewers for their insightful comments, and NSERC, CIFAR, Compute Canada and Canada Research Chairs for funding.
+
+References   
+A. Ben-Hur and J. Weston. A user’s guide to support vector machines. Methods in Molecular Biology, 609:223–239, 2010.   
+Y. Bengio, P. Lamblin, D. Popovici, and H. Larochelle. Greedy layer-wise training of deep networks. In NIPS’2006, 2007.   
+Yoshua Bengio. Learning deep architectures for AI. Foundations and Trends in Machine Learning, 2(1):1–127, 2009. Also published as a book. Now Publishers, 2009.   
+Yoshua Bengio. Evolving culture vs local minima. In Growing Adaptive Machines: Integrating Development and Learning in Artificial Neural Networks, number also as ArXiv 1203.2990v1, pages T. Kowaliw, N. Bredeche & R. Doursat, eds. Springer-Verlag, March 2013a. URL http://arxiv.org/abs/1203.2990.   
+Yoshua Bengio. Practical recommendations for gradient-based training of deep architectures. In K.-R. M¨uller, G. Montavon, and G. B. Orr, editors, Neural Networks: Tricks of the Trade. Springer, 2013b.   
+Yoshua Bengio, Jerome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In L´eon Bottou and Michael Littman, editors, Proceedings of the Twenty-sixth International Conference on Machine Learning (ICML’09). ACM, 2009a.   
+Yoshua Bengio, Jerome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ICML’09, 2009b.   
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Unsupervised feature learning and deep learning: A review and new perspectives. Technical Report arXiv:1206.5538, U. Montreal, 2012. URL http://arxiv.org/abs/1206.5538.   
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Unsupervised feature learning and deep learning: A review and new perspectives. IEEE Trans. Pattern Analysis and Machine Intelligence (PAMI), 2013.   
+James Bergstra, Olivier Breuleux, Fr´ed´eric Bastien, Pascal Lamblin, Razvan Pascanu, Guillaume Desjardins, Joseph Turian, David Warde-Farley, and Yoshua Bengio. Theano: a CPU and GPU math expression compiler. In Proceedings of the Python for Scientific Computing Conference (SciPy), 2010.   
+L´eon Bottou. Large-scale machine learning with stochastic gradient descent. In Proceedings of COMPSTAT’2010, pages 177–186. Springer, 2010.   
+Leo Breiman. Random forests. Machine Learning, 45(1):5–32, 2001.   
+D. C. Ciresan, U. Meier, L. M. Gambardella, and J. Schmidhuber. Deep big simple neural nets for handwritten digit recognition. Neural Computation, 22:1–14, 2010.   
+Yann Dauphin and Yoshua Bengio. Big neural networks waste capacity. Technical Report arXiv:1301.3583, Universite de Montreal, 2013.   
+Richard Dawkins. The Selfish Gene. Oxford University Press, 1976.
+
+J. Duchi, E. Hazan, and Y. Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12:2121–2159, 2010.
+
+Dumitru Erhan, Yoshua Bengio, Aaron Courville, Pierre-Antoine Manzagol, Pascal Vincent, and Samy Bengio. Why does unsupervised pre-training help deep learning? Journal of Machine Learning Research, 11:625–660, February 2010.
+
+Fran¸cois Fleuret, Ting Li, Charles Dubout, Emma K Wampler, Steven Yantis, and Donald Geman. Comparing machines and humans on a visual categorization test. Proceedings of the National Academy of Sciences, 108(43):17621–17625, 2011.
+
+X. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In AISTATS, 2011a.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In JMLR W&CP: Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics (AISTATS 2010), volume 9, pages 249–256, May 2010.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In JMLR W&CP: Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics (AISTATS 2011), April 2011b.
+
+Ian J. Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. In ICML, 2013.
+
+Maciej Henneberg. Decrease of human skull size in the holocene. Human biology, pages 395–405, 1988.
+
+Maciej Henneberg and Maryna Steyn. Trends in cranial capacity and cranial index in subsaharan africa during the holocene. American journal of human biology, 5(4):473–479, 1993.
+
+J. Henrich and R. McElreath. The evolution of cultural evolution. Evolutionary Anthropology: Issues, News, and Reviews, 12(3):123–135, 2003.
+
+Geoffrey E. Hinton, Simon Osindero, and Yee Whye Teh. A fast learning algorithm for deep belief nets. Neural Computation, 18:1527–1554, 2006.
+
+Geoffrey E. Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. Technical report, arXiv:1207.0580, 2012.
+
+C.W. Hsu, C.C. Chang, C.J. Lin, et al. A practical guide to support vector classification, 2003.
+
+Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multi-stage architecture for object recognition? In Proc. International Conference on Computer Vision (ICCV��09), pages 2146–2153. IEEE, 2009a.
+
+Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multi-stage architecture for object recognition? In ICCV’09, 2009b.
+
+Faisal Khan, Xiaojin Zhu, and Bilge Mutlu. How do humans teach: On curriculum learning and teaching dimension. In Advances in Neural Information Processing Systems 24 (NIPS’11), pages 1449–1457, 2011.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. ImageNet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25 (NIPS’2012). 2012.
+
+Kai A. Krueger and Peter Dayan. Flexible shaping: how learning in small steps helps. Cognition, 110:380–394, 2009.
+
+G. Kunapuli, K.P. Bennett, R. Maclin, and J.W. Shavlik. The adviceptron: Giving advice to the perceptron. Proceedings of the Conference on Artificial Neural Networks In Engineering (ANNIE 2010), 2010.
+
+Hugo Larochelle, Yoshua Bengio, Jerome Louradour, and Pascal Lamblin. Exploring strategies for training deep neural networks. Journal of Machine Learning Research, 10:1–40, 2009.
+
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+T.M. Mitchell. The need for biases in learning generalizations. Department of Computer Science, Laboratory for Computer Science Research, Rutgers Univ., 1980.
+
+T.M. Mitchell and S.B. Thrun. Explanation-based neural network learning for robot control. Advances in Neural information processing systems, pages 287–287, 1993.
+
+R. Montague. Universal grammar. Theoria, 36(3):373–398, 1970.
+
+V. Nair and G. E Hinton. Rectified linear units improve restricted Boltzmann machines. In ICML’10, 2010.
+
+L.B.J.H.F.R.A. Olshen and C.J. Stone. Classification and regression trees. Belmont, Calif.: Wadsworth, 1984.
+
+Joseph O’Sullivan. Integrating initialization bias and search bias in neural network learning, 1996.
+
+F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, et al. Scikit-learn: Machine learning in python. The Journal of Machine Learning Research, 12:2825–2830, 2011.
+
+Gail B. Peterson. A day of great illumination: B. F. Skinner’s discovery of shaping. Journal of the Experimental Analysis of Behavior, 82(3):317–328, 2004.
+
+Tapani Raiko, Harri Valpola, and Yann LeCun. Deep learning made easier by linear transformations in perceptrons. In International Conference on Artificial Intelligence and Statistics, pages 924–932, 2012.
+
+Salah Rifai, Pascal Vincent, Xavier Muller, Xavier Glorot, and Yoshua Bengio. Contractive auto-encoders: Explicit invariance during feature extraction. In ICML’2011, 2011.
+
+Salah Rifai, Yoshua Bengio, Yann Dauphin, and Pascal Vincent. A generative process for sampling contractive auto-encoders. In Proceedings of the Twenty-nine International Conference on Machine Learning (ICML’12). ACM, 2012. URL http://icml.cc/discuss/2012/590. html.
+
+R. Salakhutdinov and G.E. Hinton. Deep Boltzmann machines. In Proceedings of the Twelfth International Conference on Artificial Intelligence and Statistics (AISTATS 2009), volume 8, 2009.
+
+Burrhus F. Skinner. Reinforcement today. American Psychologist, 13:94–99, 1958.
+
+R.J. Solomonoff. A system for incremental learning based on algorithmic probability. In Proceedings of the Sixth Israeli Conference on Artificial Intelligence, Computer Vision and Pattern Recognition, pages 515–527. Citeseer, 1989.
+
+G.G. Towell and J.W. Shavlik. Knowledge-based artificial neural networks. Artificial intelligence, 70(1):119–165, 1994.
+
+Tommi Vatanen, Tapani Raiko, Harri Valpola, and Yann LeCun. Pushing stochastic gradient towards second-order methods–backpropagation learning with transformations in nonlinearities. arXiv preprint arXiv:1301.3476, 2013.
+
+Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of Machine Learning Research, 11:3371–3408, December 2010.
+
+Luis Von Ahn, Manuel Blum, Nicholas J Hopper, and John Langford. Captcha: Using hard ai problems for security. In Advances in CryptologyEUROCRYPT 2003, pages 294–311. Springer, 2003.
+
+Jason Weston, Fr´ed´eric Ratle, and Ronan Collobert. Deep learning via semi-supervised embedding. In William W. Cohen, Andrew McCallum, and Sam T. Roweis, editors, Proceedings of the Twenty-fifth International Conference on Machine Learning (ICML’08), pages 1168–1175, New York, NY, USA, 2008. ACM. ISBN 978-1-60558-205-4. doi: 10.1145/1390156.1390303.
+
+Matthew D Zeiler. Adadelta: An adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.
+
+# 5. Appendix
+
+# 5.1 Binary-Binary RBMs on Pentomino Dataset
+
+We trained binary-binary RBMs (both visible and hidden are binary) on 8 $\times$ 8 patches extracted from the Pentomino Dataset using PCD (stochastic maximum likelihood), a weight decay of .0001 and a sparsity penalty9. We used 256 hidden units and trained by SGD with a batch size of 32 and a annealing learning rate (Bengio, 2013b) starting from 1e-3 with annealing rate
+
+1.000015. The RBM is trained with momentum starting from 0.5. The biases are initialized to -2 in order to get a sparse representation. The RBM is trained for 120 epochs (approximately 50 million updates).
+
+After pretraining the RBM, its parameters are used to initialize the first layer of an SMLPnohints network. As in the usual architecture of the SMLP-nohints on top of P1NN, there is an intermediate layer. Both P1NN and the intermediate layer have a sigmoid nonlinearity, and the intermediate layer has 11 units per location. This SMLP-nohints is trained with Adadelta and standardization at the intermediate layer 10.
+
+![](images/da3e9bd04d408abcd26dfc4a0f8a671c4ca34dbd874cad9a6119b844872581fe.jpg)  
+Figure 16: Training and test errors of an SMLP-nohints network whose first layer is pre-trained as an RBM. Training error reduces to $0 \%$ at epoch 42, but test error is still chance.
+
+# 5.2 Experimental Setup and Hyper-parameters
+
+# 5.2.1 Decision Trees
+
+We used the decision tree implementation in the scikit-learn (Pedregosa et al., 2011) python package which is an implementation of the CART (Regression Trees) algorithm. The CART algorithm constructs the decision tree recursively and partitions the input space such that the samples belonging to the same category are grouped together (Olshen and Stone, 1984). We used The Gini index as the impurity criteria. We evaluated the hyper-parameter configurations with a grid-search. We cross-validated the maximum depth (max depth) of the tree (for preventing the algorithm to severely overfit the training set) and minimum number of samples required to create a split (min split). 20 different configurations of hyper-parameter values were evaluated. We obtained the best validation error with $m a x \_ d e p t h = 3 0 0$ and $\begin{array} { r } { m i n \_ s p l i t = 8 } \end{array}$ .
+
+![](images/dc66a12d545edfb396b1edd7a90fa9b2adf81cfc5150ccecca02e9f2ef88d7f8.jpg)  
+Figure 17: Filters learned by the binary-binary RBM after training on the 40k examples. The RBM did learn the edge structure of Pentomino shapes.
+
+![](images/8112ab44274578b897b7af264a18b776555ca83d1deabf752d2b2b66fe1c545a.jpg)  
+Figure 18: 100 samples generated from trained RBM. All the generated samples are valid Pentomino shapes.
+
+# 5.2.2 Support Vector Machines
+
+We used the “Support Vector Classifier (SVC)” implementation from the scikit-learn package which in turn uses the libsvm’s Support Vector Machine (SVM) implementation. Kernelbased SVMs are non-parametric models that map the data into a high dimensional space and separate different classes with hyperplane(s) such that the support vectors for each category will be separated by a large margin. We cross-validated three hyper-parameters of the model using grid-search: $C$ , $\gamma$ and the type of $\mathrm { k e r n e l } ( k e r n e l . t y p e )$ . $C$ is the penalty term (weight decay) for the SVM and $\gamma$ is a hyper-parameter that controls the width of the Gaussian for the RBF kernel. For the polynomial kernel, $\gamma$ controls the flexibility of the classifier (degree of the polynomial) as the number of parameters increases (Hsu et al., 2003; Ben-Hur and Weston, 2010). We evaluated forty-two hyper-parameter configurations. That includes, two kernel types: $\{ R B F , \ P o l y n o m i a l \}$ ; three gammas: $\{ 1 e - 2 , ~ 1 e - 3 , ~ 1 e - 4 \}$ for the RBF kernel, $\{ 1 , 2 , 5 \}$ for the polynomial kernel, and seven $C$ values among: $\{ 0 . 1 , 1 , 2 , 4 , 8 , 1 0 , 1 6 \}$ . As a result of the grid search and cross-validation, we have obtained the best test error by using the RBF kernel, with $C = 2$ and $\gamma = 1$ .
+
+# 5.2.3 Multi Layer Perceptron
+
+We have our own implementation of Multi Layer Perceptron based on the Theano (Bergstra et al., 2010) machine learning libraries. We have selected 2 hidden layers, the rectifier activation function, and 2048 hidden units per layer. We cross-validated three hyper-parameters of the model using random-search, sampling the learning rates $\epsilon$ in log-domain, and selecting $L 1$ and $L 2$ regularization penalty coefficients in sets of fixed values, evaluating 64 hyperparameter values. The range of the hyperparameter values are $\epsilon \in [ 0 . 0 0 0 1 , 1 ]$ , $L 1 \in \{ 0 . , 1 e - 6 , 1 e - 5 , 1 e - 4 \}$ and $L 2 \in \{ 0 , 1 e - 6 , 1 e - 5 \}$ . As a result, the following were selected: $L 1 = 1 e - 6$ , $L 2 = 1 e - 5$ and $\epsilon = 0 . 0 5$ .
+
+# 5.2.4 Random Forests
+
+We used scikit-learn’s implementation of “Random Forests” decision tree learning. The Random Forests algorithm creates an ensemble of decision trees by randomly selecting for each tree a subset of features and applying bagging to combine the individual decision trees (Breiman, 2001). We have used grid-search and cross-validated the max depth, min split, and number of trees $( n \_ e s t i m a t o r s )$ . We have done the grid-search on the following hyperparameter values, n estimators $\in \ \{ 5 , 1 0 , 1 5 , 2 5 , 5 0 \}$ , $m a x \_ d e p t h \in \ \{ 1 0 0 , 3 0 0 , 6 0 0 , 9 0 0 \}$ , and min splits ∈ $\{ 1 , 4 , 1 6 \}$ . We obtained the best validation error with max depth = 300, min split = 4 and n estimators = 10.
+
+# 5.2.5 k-Nearest Neighbors
+
+We used scikit-learn’s implementation of k-Nearest Neighbors (k-NN). k-NN is an instancebased, lazy learning algorithm that selects the training examples closest in Euclidean distance to the input query. It assigns a class label to the test example based on the categories of the $k$ closest neighbors. The hyper-parameters we have evaluated in the cross-validation are the number of neighbors ( $k$ ) and weights. The weights hyper-parameter can be either “uniform” or “distance”. With “uniform”, the value assigned to the query point is computed by the majority vote of the nearest neighbors. With “distance”, each value assigned to the query point is computed by weighted majority votes where the weights are computed with the inverse distance between the query point and the neighbors. We have used $n . n e i g h b o u r s \in \{ 1 , 2 , 4 , 6 , 8 , 1 2 \}$ and $w e i g h t s \in \{ " , u n i f o r m " , " d i s t a n c e " \}$ for hyper-parameter search. As a result of cross-validation and grid search, we obtained the best validation error with $k = 2$ and weights=“uniform”.
+
+# 5.2.6 Convolutional Neural Nets
+
+We used a Theano (Bergstra et al., 2010) implementation of Convolutional Neural Networks (CNN) from the deep learning tutorial at deeplearning.net, which is based on a vanilla version of a CNN LeCun et al. (1998). Our CNN has two convolutional layers. Following each convolutional layer, we have a max-pooling layer. On top of the convolution-poolingconvolution-pooling layers there is an MLP with one hidden layer. In the cross-validation we have sampled 36 learning rates in log-domain in the range [0.0001, 1] and the number of filters from the range [10, 20, 30, 40, 50, 60] uniformly. For the first convolutional layer we used 9 $\times$ 9 receptive fields in order to guarantee that each object fits inside the receptive field. As a result of random hyperparameter search and doing manual hyperparameter search on the validation dataset, the following values were selected:
+
+• The number of features used for the first layer is 30 and the second layer is 60.   
+• For the second convolutional layer, 7 $\times$ 7 receptive fields. The stride for both convolutional layers is 1.   
+• Convolved images are downsampled by a factor of 2 $\times$ 2 at each pooling operation.   
+• The learning rate for CNN is 0.01 and it was trained for 8 epochs.
+
+# 5.2.7 Maxout Convolutional Neural Nets
+
+We used the pylearn2 (https://github.com/lisa-lab/pylearn2) implementation of maxout convolutional networks (Goodfellow et al., 2013). There are two convolutional layers in the selected architecture, without any pooling. In the last convolutional layer, there is a maxout non-linearity. The following were selected by cross-validation: learning rate, number of channels for the both convolution layers, number of kernels for the second layer and number of units and pieces per maxout unit in the last layer, a linearly decaying learning rate, momentum starting from 0.5 and saturating to 0.8 at the 200’th epoch. Random search for the hyperparameters was used to evaluate 48 different hyperparameter configurations on the validation dataset. For the first convolutional layer, 8 $\times$ 8 kernels were selected to make sure that each Pentomino shape fits into the kernel. Early stopping was used and test error on the model that has the best validation error is reported. Using norm constraint on the fan-in of the final softmax units yields slightly better result on the validation dataset.
+
+As a result of cross-validation and manually tuning the hyperparameters we used the following hyperparameters:
+
+• 16 channels per convolutional layer. 600 hidden units for the maxout layer.
+
+• 6x6 kernels for the second convolutional layer.
+
+• 5 pieces for the convolution layers and 4 pieces for the maxout layer per maxout units.
+
+• We decayed the learning rate by the factor of 0.001 and the initial learning rate is 0.026367. But we scaled the learning rate of the second convolutional layer by a constant factor of 0.6.
+
+• The norm constraint (on the incoming weights of each unit) is 1.9365.
+
+Figure 19 shows the first layer filters of the maxout convolutional net, after being trained on the 80k training set for 85 epochs.
+
+![](images/3be18461b47f63365d3d650b76a615da3eb241b0c9d2b0be0602457dca4fed4d.jpg)
+
+Figure 19: Maxout convolutional net first layer filters. Most of the filters were able to learn the basic edge structure of the Pentomino shapes.
+
+# 5.2.8 Stacked Denoising Auto-Encoders
+
+Denoising Auto-Encoders (DAE) are a form of regularized auto-encoder (Bengio et al., 2013). The DAE forces the hidden layer to discover more robust features and prevents it from simply learning the identity by reconstructing the input from a corrupted version of it (Vincent et al., 2010). Two DAEs were stacked, resulting in an unsupervised transformation with two hidden layers of 1024 units each. Parameters of all layers are then fine-tuned with supervised finetuning using logistic regression as the classifier and SGD as the gradient-based optimization algorithm. The stochastic corruption process is binomial ( $0$ or 1 replacing each input value, with probability 0.2). The selected learning rate is $\epsilon _ { 0 } = 0 . 0 1$ for the DAe and $\epsilon _ { 1 } = 0 . 1$ for supervised fine-tuning. Both L1 and L2 penalty for the DAEs and for the logistic regression layer are set to 1e-6.
+
+CAE+MLP with Supervised Finetuning: A regularized auto-encoder which sometimes outperforms the DAE is the Contractive Auto-Encoder (CAE), (Rifai et al., 2012), which penalizes the Frobenius norm of the Jacobian matrix of derivatives of the hidden units with respect to the CAE’s inputs. The CAE serves as pre-training for an MLP, and in the supervised fine-tuning state, the Adagrad method was used to automatically tune the learning rate (Duchi et al., 2010).
+
+After training a CAE with 100 sigmoidal units patch-wise, the features extracted on each patch are concatenated and fed as input to an MLP. The selected Jacobian penalty coefficient is 2, the learning rate for pre-training is 0.082 with batch size of 200 and 200 epochs of unsupervised learning are performed on the training set. For supervised finetuning, the learning rate is 0.12 over 100 epochs, L1 and L2 regularization penalty terms respectively are 1e-4 and 1e-6, and the top-level MLP has 6400 hidden units.
+
+Greedy Layerwise CAE+DAE Supervised Finetuning: For this experiment we stack a CAE with sigmoid non-linearities and then a DAE with rectifier non-linearities during the pretraining phase. As recommended by Glorot et al. (2011b) we have used a softplus nonlinearity for reconstruction, $s o f t p l u s ( x ) = l o g ( 1 + e ^ { x } )$ . We used an L1 penalty on the rectifier outputs to obtain a sparser representation with rectifier non-linearity and L2 regularization to keep the non-zero weights small.
+
+The main difference between the DAE and CAE is that the DAE yields more robust reconstruction whereas the CAE obtains more robust features (Rifai et al., 2011).
+
+As seen on Figure 7 the weights U and V are shared on each patch and we concatenate the outputs of the last auto-encoder on each patch to feed it as an input to an MLP with a large hidden layer.
+
+We used 400 hidden units for the CAE and 100 hidden units for DAE. The learning rate used for the CAE is 0.82 and for DAE it is ${ 9 ^ { * } } 1 { \mathrm { e } } { - 3 }$ . The corruption level for the DAE (binomial noise) is 0.25 and the contraction level for the CAE is 2.0. The L1 regularization penalty for the DAE is 2.25\*1e-4 and the L2 penalty is $9 . 5 ^ { * } 1 \mathrm { e } \mathrm { - } 5$ . For the supervised finetuning phase the learning rate used is 4\*1e-4 with L1 and L2 penalties respectively 1e-5 and 1e-6. The top-level MLP has 6400 hidden units. The auto-encoders are each trained for 150 epochs while the whole MLP is fine-tuned for 50 epochs.
+
+Greedy Layerwise DAE+DAE Supervised Finetuning: For this architecture, we have trained two layers of denoising auto-encoders greedily and performed supervised finetuning after unsupervised pre-training. The motivation for using two denoising auto-encoders is the fact that rectifier nonlinearities work well with the deep networks but it is difficult to train CAEs with the rectifier non-linearity. We have used the same type of denoising auto-encoder that is used for the greedy layerwise CAE+DAE supervised finetuning experiment.
+
+In this experiment we have used 400 hidden units for the first layer DAE and 100 hidden units for the second layer DAE. The other hyperparameters for DAE and supervised finetuning are the same as with the CAE+DAE MLP Supervised Finetuning experiment.

parse/train/ehJqJQk9cw/ehJqJQk9cw.md

@@ -0,0 +1,346 @@
+# PERSONALIZED FEDERATED LEARNING WITH FIRST ORDER MODEL OPTIMIZATION
+
+Michael Zhang∗   
+Stanford University   
+mzhang@cs.stanford.edu   
+Karan Sapra   
+NVIDIA   
+ksapra@nvidia.com   
+Sanja Fidler   
+NVIDIA   
+sfidler@nvidia.com
+
+Serena Yeung Stanford University syyeung@stanford.edu
+
+Jose M. Alvarez NVIDIA josea@nvidia.com
+
+# ABSTRACT
+
+While federated learning traditionally aims to train a single global model across decentralized local datasets, one model may not always be ideal for all participating clients. Here we propose an alternative, where each client only federates with other relevant clients to obtain a stronger model per client-specific objectives. To achieve this personalization, rather than computing a single model average with constant weights for the entire federation as in traditional FL, we efficiently calculate optimal weighted model combinations for each client, based on figuring out how much a client can benefit from another’s model. We do not assume knowledge of any underlying data distributions or client similarities, and allow each client to optimize for arbitrary target distributions of interest, enabling greater flexibility for personalization. We evaluate and characterize our method on a variety of federated settings, datasets, and degrees of local data heterogeneity. Our method outperforms existing alternatives, while also enabling new features for personalized FL such as transfer outside of local data distributions.
+
+# 1 INTRODUCTION
+
+Federated learning (FL) has shown great promise in recent years for training a single global model over decentralized data. While seminally motivated by effective inference on a general test set similar in distribution to the decentralized data in aggregate (McMahan et al., 2016; Bonawitz et al., 2019), here we focus on federated learning from a client-centric or personalized perspective. We aim to enable stronger performance on personalized target distributions for each participating client. Such settings can be motivated by cross-silo FL, where clients are autonomous data vendors (e.g. hospitals managing patient data, or corporations carrying customer information) that wish to collaborate without sharing private data (Kairouz et al., 2019). Instead of merely being a source of data and model training for the global server, clients can then take on a more active role: their federated participation may be contingent on satisfying client-specific target tasks and distributions. A strong FL framework in practice would then flexibly accommodate these objectives, allowing clients to optimize for arbitrary distributions simultaneously in a single federation.
+
+In this setting, FL’s realistic lack of an independent and identically distributed (IID) data assumption across clients may be both a burden and a blessing. Learning a single global model across non-IID data batches can pose challenges such as non-guaranteed convergence and model parameter divergence (Hsieh et al., 2019; Zhao et al., 2018; Li et al., 2020). Furthermore, trying to fine-tune these global models may result in poor adaptation to local client test sets (Jiang et al., 2019). However, the non-IID nature of each client’s local data can also provide useful signal for distinguishing their underlying local data distributions, without sharing any data. We leverage this signal to propose a new framework for personalized FL. Instead of giving all clients the same global model average weighted by local training size as in prior work (McMahan et al., 2016), for each client we compute a weighted combination of the available models to best align with that client’s interests, modeled by evaluation on a personalized target test distribution.
+
+Key here is that after each federating round, we maintain the client-uploaded parameters individually, allowing clients in the next round to download these copies independently of each other. Each federated update is then a two-step process: given a local objective, clients (1) evaluate how well their received models perform on their target task and (2) use these respective performances to weight each model’s parameters in a personalized update. We show that this intuitive process can be thought of as a particularly coarse version of popular iterative optimization algorithms such as SGD, where instead of directly accessing other clients’ data points and iteratively training our model with the granularity of gradient decent, we limit ourselves to working with their uploaded models. We hence propose an efficient method to calculate these optimal combinations for each client, calling it FedFomo, as (1) each client’s federated update is calculated with a simple first-order model optimization approximating a personalized gradient step, and (2) it draws inspiration from the “fear of missing out”, every client no longer necessarily factoring in contributions from all active clients during each federation round. In other words, curiosity can kill the cat. Each model’s personalized performance can be saved however by restricting unhelpful models from each federated update.
+
+We evaluate our method on federated image classification and show that it outperforms other methods in various non-IID scenarios. Furthermore, we show that because we compute federated updates directly with respect to client-specified local objectives, our framework can also optimize for outof-distribution performance, where client’s target distributions are different from their local training ones. In contrast, prior work that personalized based on similarity to a client’s own model parameters (Mansour et al., 2020; Sattler et al., 2020) restricts this optimization to the local data distribution. We thus enable new features in personalized FL, and empirically demonstrate up to $7 0 \%$ improvement in some settings, with larger gains as the number of clients or level of non-IIDness increases.
+
+# Our contributions
+
+1. We propose a flexible federated learning framework that allows clients to personalize to specific target data distributions irrespective of their available local training data. 2. Within this framework, we introduce a method to efficiently calculate the optimal weighted combination of uploaded models as a personalized federated update 3. Our method strongly outperforms other methods in non-IID federated learning settings.
+
+# 2 RELATED WORK
+
+Federated Learning with Non-IID Data While fine-tuning a global model on a client’s local data is a natural strategy to personalize (Mansour et al., 2020; Wang et al., 2019), prior work has shown that non-IID decentralized data can introduce challenges such as parameter divergence (Zhao et al., 2018), data distribution biases (Hsieh et al., 2019), and unguaranteed convergence Li et al. (2020). Several recent methods then try to improve the robustness of global models under heavily non-IID datasets. FedProx (Li et al., 2020) adds a proximal term to the local training objective to keep updated parameter close to the original downloaded model. This serves to reduce potential weight divergence defined in Zhao et al. (2018), who instead allow clients to share small subsets of their data among each other. This effectively makes each client’s local training set closer in distribution to the global test set. More recently, Hsu et al. (2019) propose to add momentum to the global model update in FedAvgM to reduce the possibly harmful oscillations associated with averaging local models after several rounds of stochastic gradient descent for non-identically distributed data.
+
+While these advances may make a global model more robust across non-IID local data, they do not directly address local-level data distribution performance relevant to individual clients. Jiang et al. (2019) argue this latter task may be more important in non-IID FL settings, as local training data differences may suggest that only a subset of all potential features are relevant to each client. Their target distributions may be fairly different from the global aggregate in highly personalized scenarios, with the resulting dataset shift difficult to handle with a single model.
+
+Personalized Federated Learning Given the challenges above, other approaches train multiple models or personalizing components to tackle multiple target distributions. Smith et al. (2017) propose multi-task learning for FL with MOCHA, a distributed MTL framework that frames clients as tasks and learns one model per client. Mixture methods (Deng et al., 2020; Hanzely & Richtarik, ´
+
+2020; Mansour et al., 2020) compute personalized combinations of model parameters from training both local models and the global model, while Peterson et al. (2019) ensure that this is done with local privacy guarantees. Liang et al. (2020) apply this mixing across network layers, with lower layers acting as local encoders that map a client’s observed data to input for a globally shared classifier. Rather than only mix with a shared global model, our work allows for greater control and distinct mixing parameters with multiple local models. Fallah et al. (2020) instead optimize the global model for fast personalization through meta-learning, while T Dinh et al. (2020) train global and local models under regularization with Moreau envelopes. Alternatively, Clustered FL (Sattler et al., 2020; Ghosh et al., 2020; Briggs et al., 2020; Mansour et al., 2020) assumes that inherent partitions or data distributions exist behind clients’ local data, and aim to cluster these partitions to federate within each cluster. Our work does not restrict which models are computed together, allowing clients to download suitable models independently. We also compute client-specific weighted averages for greater personalization. Finally, unlike prior work, we allow clients to receive personalized updates for target distributions different from their local training data.
+
+# 3 FEDERATED FIRST ORDER MODEL OPTIMIZATION
+
+We now present FedFomo, a personalized FL framework to efficiently compute client-optimizing federated updates. We adopt the general structure of most FL methods, where we iteratively cycle between downloading model parameters from server to client, training the models locally on each client’s data, and sending back the updated models for future rounds. However, as we do not compute a single global model, each federated download introduces two new steps: (1) figuring out which models to send to which clients, and (2) computing their personalized weighted combinations. We define our problem and describe how we accomplish (1) and (2) in the following sections.
+
+Problem Definition and Notation Our work most naturally applies to heterogeneous federated settings where participating clients are critically not restricted to single local training or target test distribution, and apriori we do not know anything about these distributions. To model this, let $\mathbb { C }$ be a population with $| \mathbb { C } | = K$ total clients, where each client $c _ { i } \in \mathbb { C }$ carries local data $\mathbf { \nabla } D _ { i }$ sampled from some distribution D and local model parameters θ\`(t)i during any round $t$ . Each $c _ { i }$ also maintains some personalized objective or task $\mathcal { T } _ { i }$ motivating their participation in the federation. We focus on supervised classification as a universal task setting. Each client and task are then associated with a test dataset $D _ { i } ^ { \mathrm { t e s t } } \sim D ^ { * }$ . We define each $\mathcal { T } _ { i } : = \operatorname* { m i n } \mathcal { L } ( \boldsymbol { \theta } _ { i } ^ { \ell ( t ) } ; D _ { i } ^ { \mathrm { t e s t } } )$ , where $\mathcal { L } ( \boldsymbol { \theta } ; \boldsymbol { D } ) : \Theta \mapsto \mathbb { R }$ is the loss function associated with dataset $_ D$ , and $\Theta$ denotes the space of models possible with our presumed network architecture. We assume no knowledge regarding clients and their data distributions, nor that test and local data belong to the same distribution. We aim to obtain the optimal set of model parameters $\begin{array} { r } { \{ \theta _ { 1 } ^ { * } , \ldots , \theta _ { K } ^ { * } \} = \arg \operatorname* { m i n } \sum _ { i \in [ K ] } \mathcal { L } _ { \mathcal { T } _ { i } } ( \theta _ { i } ) } \end{array}$ .
+
+# 3.1 COMPUTING FEDERATED UPDATES WITH FOMO
+
+Unlike previous work in federated learning, FedFomo learns optimal combinations of the available server models for each participating client. To do so, we leverage information from clients in two different ways. First, we aim to directly optimize for each client’s target objective. We assume that clients can distinguish between good and bad models on their target tasks, through the use of a labeled validation data split $D _ { i } ^ { \mathrm { v a l } } \subset D _ { i }$ in the client’s local data. $\mathrm { \bar { \it D } } _ { i } ^ { \mathrm { v a l } }$ should be similar in distribution to the target test dataset $\mathbf { \mathbf { \mathbf { } } } D _ { i } ^ { \mathrm { t e s t } }$ . The client can then evaluate any arbitrary model $\theta _ { j }$ on this validation set, and quantify the performance through the computed loss, denoted by $\mathcal { L } _ { i } ( \boldsymbol { \theta } _ { j } )$ . Second, we directly leverage the potential heterogeneity among client models. Zhao et al. (2018) explore this phenomenon as a failure mode for traditional single model FL, where they show that diverging model weights come directly from local data heterogeneity. However, instead of combining these parameters into a single global model, we maintain the uploaded models individually as a means to preserve a model’s potential contribution to another client. Critically, these two ideas together not only allow us to compute more personal model updates within non-IID local data distributions, but also enable clients to optimize for data distributions different from their own local data’s.
+
+Federated learning as an iterative local model update The central premise of our work stems from viewing each federated model download−and subsequent changing of local model parameters−as an optimization step towards some objective. In traditional FL, this objective involves performing well on the global population distribution, similar in representation to the union of all local datasets. Assuming $N$ federating clients, we compute each global model $\theta ^ { G }$ at time $t$ as:
+
+$\begin{array} { r } { \theta ^ { G ( t ) } = \sum _ { n = 1 } ^ { N } w _ { n } \cdot \theta _ { n } ^ { \ell ( t ) } } \end{array}$ , where $w _ { n } = | D _ { n } ^ { \mathrm { t r a i n } } | / \sum _ { j = 1 } ^ { N } | D _ { j } ^ { \mathrm { t r a i n } } |$ . If client $c _ { i }$ downloads this model, we casince hange to their local model as an update: . This then updates a client’s current l $\begin{array} { r } { \theta _ { i } ^ { \ell ( t + 1 ) }  \theta _ { i } ^ { \ell ( t ) } + \sum _ { n = 1 } ^ { N } w _ { n } \cdot \big ( \theta _ { n } ^ { \ell ( t ) } - \theta _ { i } ^ { \ell ( t ) } \big ) } \end{array}$ $\textstyle \sum _ { n } w _ { n } = 1$ fied by the weights $\pmb { w }$ and models $\left\{ \theta _ { n } \right\}$ in the federation. A natural choice to optimize for the global target distribution sets $w _ { n }$ as above and in McMahan et al. (2017), e.g. as an unbiased estimate of global model parameters. However, in our personalized scenario, we are more interested in computing the update uniquely with respect to each client’s target task. We then wish to find the optimal weights $\pmb { w } = \langle w _ { 1 } , \dots , w _ { N } \rangle$ that optimize for the client’s objective, minimizing $\mathcal { L } _ { i } ( \theta _ { i } ^ { \ell } )$ .
+
+Efficient personalization with FedFomo Intuitively, we wish to find models $\{ \theta _ { m } ^ { \ell ( t ) } : m \in [ N ] \backslash i \}$ such that moving towards their parameters leads to better performance on our target distribution, and accordingly weight these $\theta$ higher in a model average. If a client carries a satisfying number of local data points associated with their target objective $\mathcal { L } _ { i }$ , then they could obtain a reasonable model through local training alone, e.g. directly updating their model parameters through SGD:
+
+$$
+\boldsymbol { \theta } _ { i } ^ { \ell ( t + 1 ) } \gets \boldsymbol { \theta } _ { i } ^ { \ell ( t ) } - \alpha \nabla _ { \boldsymbol { \theta } } \mathcal { L } _ { i } ( \boldsymbol { \theta } _ { i } ^ { \ell ( t ) } )
+$$
+
+However, without this data, clients are more motivated to federate. In doing so they obtain useful updates, albeit in the more restricted form of fixed model parameters $\{ \theta _ { n } : n \in N \}$ . Then for personalized or non-IID target distributions, we can iteratively solve for the optimal combination of client models ${ \pmb w } ^ { * } = \arg \operatorname* { m i n } \mathcal { L } _ { i } ( { \boldsymbol { \theta } } )$ by computing:
+
+$$
+\boldsymbol { \theta } _ { i } ^ { \ell ( t + 1 ) } \gets \boldsymbol { \theta } _ { i } ^ { \ell ( t ) } - \alpha \mathbf { 1 } ^ { \top } \nabla _ { w } \mathcal { L } _ { i } ( \boldsymbol { \theta } _ { i } ^ { \ell ( t ) } )
+$$
+
+where 1 is a size- $N$ vector of ones. Unfortunately, as the larger federated learning algorithm is already an iterative process with many rounds of communication, computing $\boldsymbol { w } ^ { * }$ through Eq. 2 may be cumbersome. Worse, if the model averages are only computed server-side as in traditional FL, Eq. 2 becomes prohibitively expensive in communication rounds (McMahan et al., 2017).
+
+Following this line of reasoning however, we thus derive an approximation of $\pmb { w } ^ { * }$ for any client: Given previous local model parameters $\theta _ { i } ^ { \ell ( t - 1 ) }$ , set of fellow federating models available to download $\{ \theta _ { n } ^ { \ell ( t ) } \}$ and local client objective captured by $\mathcal { L } _ { i }$ , we propose weights of the form:
+
+$$
+w _ { n } = \frac { \mathcal { L } _ { i } ( \boldsymbol { \theta } _ { i } ^ { \ell ( t - 1 ) } ) - \mathcal { L } _ { i } ( \boldsymbol { \theta } _ { n } ^ { \ell ( t ) } ) } { \Vert \boldsymbol { \theta } _ { n } ^ { \ell ( t ) } - \boldsymbol { \theta } _ { i } ^ { \ell ( t - 1 ) } \Vert }
+$$
+
+where the resulting federated update $\begin{array} { r } { \theta _ { i } ^ { \ell { ( t ) } }  \theta _ { i } ^ { \ell { ( t - 1 ) } } + \sum _ { n \in [ N ] } w _ { n } ( \theta _ { n } ^ { \ell { ( t ) } } { - } \theta _ { i } ^ { \ell { ( t - 1 ) } } ) } \end{array}$ directly optimizes for client $c _ { i }$ ’s objective up to a first-order approximation of the optimal $\boldsymbol { w } ^ { * }$ . We default to the original parameters $\theta _ { i } ^ { \ell ( t - 1 ) }$ if $w _ { n } < 0$ above, i.e. $w _ { n } = \operatorname* { m a x } ( w _ { n } , 0 )$ , and among positive $w _ { n }$ normalize to get final weights $\begin{array} { r } { w _ { n } ^ { * } = \frac { \operatorname* { m a x } ( w _ { n } , 0 ) } { \sum _ { n } \operatorname* { m a x } ( w _ { n } , 0 ) } } \end{array}$ to maintain $w ^ { \ast } \in [ 0 , 1 ]$ and $\textstyle \sum _ { n = 1 } w _ { n } ^ { * } \in \{ 0 , 1 \}$ .
+
+We derive Eq. 3 as a first-order approximation of $\mathbf { w } ^ { * }$ in Appendix A.1. Here we note that our formulation captures the intuition of federating with client models that perform better than our own model, e.g. have a smaller loss on $\mathcal { L } _ { i }$ . Moreso, we weigh models more heavily as this positive loss delta increases, or the distance between our current parameters and theirs decreases, in essence most heavily weighing the models that most efficiently improve our performance. We use local parameters at $t$ -1 to directly compute how much we should factor in current parameters $\theta _ { i } ^ { \ell ( t ) }$ , which also helps prevent overfitting as $\mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } ) - \mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t ) } ) < 0$ causes “early-stopping” at $\theta _ { i } ^ { \ell ( t - 1 ) }$ .
+
+Communication and bandwidth overhead Because the server can send multiple requested models in one download to any client, we still maintain one round of communication for model downloads and one round for uploads in between $E$ local training epochs. Furthermore, because $\pmb { w }$ in Eq. 3 is simple to calculate, the actual model update can also happen client-side, keeping the total number of communications with $T$ total training epochs at $\lfloor \frac { 2 T } { E } \rfloor$ , as in FedAvg.
+
+However FedFomo also needs to consider the additional bandwidth from downloading multiple models. While quantization and distillation (Chen et al., 2017; Hinton et al., 2015; Xu et al., 2018) can alleviate this, we also avoid worst case $N ^ { 2 }$ overhead with respect to the number of active clients
+
+$N$ by restricting the number of models downloaded $M$ . Whether we can achieve good personalization here involves figuring out which models benefit which clients, and our goal is then to send as many helpful models as possible given limited bandwidth.
+
+To do so, we invoke a sampling scheme where the likelihood of sending model $\theta _ { j }$ to client $c _ { i }$ relies on how well $\theta _ { j }$ performed regarding client $c _ { i }$ ’s target objective in previous rounds. Accordingly, we maintain an affinity matrix $_ { P }$ composed of vectors $\pmb { p _ { i } } = \langle p _ { i , 1 } , . . . , p _ { i , K } \rangle$ , where $p _ { i , j }$ measures the likelihood of sending $\theta _ { j }$ to client $c _ { i }$ , and at each round send the available uploaded models corresponding to the top $M$ values according to each participating client’s $\pmb { p }$ . Initially we set $\pmb { P } = \mathrm { d i a g } ( 1 , \hat { . . . , 1 } )$ , i.e. each model has an equal chance of being downloaded. Then during each federated update, we update $\pmb { p }  \pmb { p } + \pmb { w }$ from Eq. 3, where $\textbf { \em w }$ can now be negative. If $N \ll K$ , we may benefit from additional exploration, and employ an $\varepsilon$ -greedy sampling strategy where instead of picking strictly in order of $\pmb { p }$ , we have $\varepsilon$ chance to send a random model to the client. We investigate the robustness of FedFomo to these parameters through ablations of $\varepsilon$ and $M$ in the next section.
+
+# 4 EXPERIMENTS
+
+Experimental Setup We consider two different scenarios for simulating non-identical data distributions across federating clients. First we evaluate with the pathological non-IID setup in McMahan et al. (2016), where each client is randomly assigned 2 classes among 10 total classes. We also use a latent distribution non-IID setup, where we first partition our datasets based on feature and semantic similarity, and then sample from them to setup different local client data distributions. We use number of distributions $\in \{ 2 , 3 , 4 , 5 , 1 0 \}$ and report the average Earth Mover’s Distance (EMD) between local client data and the total dataset across all clients to quantify non-IIDness. We evenly allocate clients among distributions and include further details in Appendix A.5. We evaluate under both setups with two FL scenarios: 15 and 100 clients with $1 0 0 \%$ and $1 0 \%$ participation respectively, reporting final accuracy after training with $E = 5$ local epochs per round for 20 communication rounds in the former and 100 rounds in the latter. Based on prior work (McMahan et al., 2016; Liang et al., 2020), we compare methods with the MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky et al., 2009), and CIFAR-100 datasets. We use the same CNN architecture as in McMahan et al. (2016).
+
+Federated Learning Baselines We compare FedFomo against methods broadly falling under two categories: they (1) propose modifications to train a single global model more robust to non-IID local datasets, or (2) aim to train more than one model or model component to personalize performance directly to client test sets. For (1), we consider FedAvg, FedProx, and the $5 \%$ data-sharing strategy with FedAvg, while in (2) we compare our method to MOCHA, LG-FedAvg, Per-FedAvg, pFedMe, Clustered Federated Learning (CFL), and a local training baseline. All accuracies are reported with mean and standard deviation over three runs, with local training epochs $E = 5$ , the same number of communication rounds (20 for 15 clients, $1 0 0 \%$ participation; 100 for 100 clients, $1 0 \%$ participation) and learning rate 0.01 for MNIST, 0.1 for CIFAR-10). We implemented all results1.
+
+Pathological Non-IID We follow precedent and report accuracy after assigning two classes out of the ten to each client for the pathological setting in Table 1. Across datasets and client setups, our proposed FedFomo strongly outperforms alternative methods in settings with larger number clients, and achieves competitive accuracy in the 15 client scenario. In the larger 100 client scenario, each individual client participates less frequently but also carries less local training data. Such settings motivate a higher demand for efficient federated updates, as there are less training rounds for each client overall. Meanwhile, methods that try to train a single robust model perform with mixed success over the FedAvg baseline, and notably do not perform better than local training alone. Despite the competitive performance, we note that this pathological setting is not the most natural scenario to apply FedFomo. In particular when there are less clients, each client’s target distribution carries only 2 random classes, there is no guarantee that any two clients share the same objective such that they can clearly benefit each other. With more clients however, we can also expect higher frequencies of target distribution overlap, and accordingly find that we outperform all other methods.
+
+Latent Distribution Non-IID We next report how each FL method performs in the latent distribution setting in Table 2, with additional results in Fig. 1. Here we study the relative performance of
+
+<table><tr><td rowspan="2"></td><td colspan="2">MNIST</td><td colspan="2">CIFAR-10</td></tr><tr><td>15 clients</td><td>100 clients</td><td>15 clients</td><td>100 clients</td></tr><tr><td>Local Training</td><td>99.62 ± 0.21</td><td>94.25 ± 4.28</td><td>92.73 ± 0.87</td><td>85.42 ± 4.06</td></tr><tr><td>FedAvg (McMahan et al., 2016)</td><td>91.97 ± 2.17</td><td>78.83 ± 9.68</td><td>57.12 ± 1.14</td><td>53.08 ± 7.40</td></tr><tr><td>FedAvg +Data (Zhao et al., 2018)</td><td>91.99 ± 2.14</td><td>78.85 ± 9.66</td><td>58.5 ± 1.67</td><td>56.62 ± 8.92</td></tr><tr><td>FedProx (Li et al., 2020)</td><td>90.94 ± 1.85</td><td>79.06 ±10.88</td><td>54.60 ± 3.26</td><td>52.92 ± 5.56</td></tr><tr><td>LG-FedAvg (Liang et al., 2020)</td><td>99.79 ±0.07</td><td>84.17 ±1.92</td><td>92.36 ±1.00</td><td>84.17 ± 4.45</td></tr><tr><td>MOCHA (Smith et al., 2017)</td><td>94.74±2.27</td><td>84.58 ± 5.80</td><td>93.85 ±2.04</td><td>76.09 ± 8.49</td></tr><tr><td>Clustered FL (CFL) (Sattler et al., 2020)</td><td>95.00 ± 3.61</td><td>92.26 ± 3.91</td><td>85.07 ±8.16</td><td>77.75 ± 1.78</td></tr><tr><td>Per-FedAvg (Fallah et al.,2020)</td><td>92.39 ± 4.72</td><td>85.32 ± 12.93</td><td>81.96 ± 8.12</td><td>72.40 ± 4.06</td></tr><tr><td>pFedMe (TDinh et al., 2020)</td><td>97.70 ±1.26</td><td>88.40 ±10.86</td><td>83.85 ± 5.11</td><td>71.75 ± 6.78</td></tr><tr><td>Ours (5 clients downloaded)</td><td>99.62 ± 2.91</td><td>98.81 ±1.26</td><td>93.01 ±0.96</td><td>92.10 ± 5.20</td></tr><tr><td>Ours (10 clients downloaded)</td><td>99.63 ± 0.07</td><td>98.71 ± 2.86</td><td>92.73 ± 0.96</td><td>92.67 ± 4.21</td></tr></table>
+
+Table 1: Personalized FL accuracy with pathological non-IID splits. Best results in bold. FedFomo outperforms or is competitive with prior work across settings, especially with larger populations.
+
+FedFomo across various levels of statistical heterogeneity, and again show that our method strongly outperforms others in highly non-IID settings. The performance gap widens as local datasets become more non-IID, where global FL methods may suffer more from combining increasingly divergent weights while also experiencing high target data distribution shift (quantified with higher EMD) due to local data heterogeneity. Sharing a small amount of data among clients uniformly helps, as does actively trying to reduce this divergence through FedProx, but higher performance most convincingly come from methods that do not rely on a single model. The opposite trend occurs with local training, as more distributions using the same 10 or 100 classes leads to smaller within-distribution variance. Critically, FedFomo is competitive with local training in the most extreme non-IID case while strongly outperforming FedAvg, and outperforms both in moderately non-IID settings $( \mathrm { E M D } \in [ 1 , 2 ] ,$ ), suggesting that we can selectively leverage model updates that best fit client objectives to justify federating. When data is more IID, any individual client model may benefit another, and it becomes harder for a selective update to beat a general model average. FedFomo also outperforms personalizing-component and multi-model approaches (MOCHA and LG-FedAvg), where regarding data heterogeneity we see similar but weaker and more stochastic trends in performance.
+
+<table><tr><td></td><td colspan="5">CIFAR-10 Number of Latent Distributions (EMD)</td></tr><tr><td>Method</td><td>2 (1.05)</td><td>3 (1.41)</td><td>4 (1.28)</td><td>5 (2.80)</td><td>10 (2.70)</td></tr><tr><td>Local Training</td><td>60.03 ± 9.22</td><td>66.61 ± 9.90</td><td>69.12 ± 12.07</td><td>76.52 ± 11.46</td><td>92.64 ± 7.32</td></tr><tr><td>FedAvg</td><td>38.92 ±11.88</td><td>21.56 ± 9.14</td><td>22.34± 12.36</td><td>32.13 ± 1.95</td><td>10.10 ± 3.65</td></tr><tr><td>FedAvg +Data</td><td>53.43 ± 2.89</td><td>33.87 ± 2.53</td><td>65.73 ±1.07</td><td>63.32 ± 0.49</td><td>41.61 ± 0.92</td></tr><tr><td>FedProx</td><td>66.42 ±1.79</td><td>31.38 ± 2.54</td><td>50.61 ± 1.53</td><td>48.20±0.14</td><td>13.41 ± 3.39</td></tr><tr><td>LG-FedAvg</td><td>70.87 ±1.12</td><td>74.16 ± 2.37</td><td>67.25 ±1.97</td><td>63.64 ± 2.52</td><td>94.42 ±1.25</td></tr><tr><td>MOCHA</td><td>83.79 ±1.54</td><td>73.68 ± 2.80</td><td>71.23 ± 4.08</td><td>69.02 ± 2.93</td><td>94.28 ± 0.81</td></tr><tr><td>CFL</td><td>72.58 ± 10.30</td><td>75.69 ±1.11</td><td>78.31 ± 12.90</td><td>70.04 ± 13.56</td><td>85.22 ± 6.70</td></tr><tr><td>Per-FedAvg</td><td>63.85 ± 5.11</td><td>69.70± 7.27</td><td>72.60 ± 9.28</td><td>76.61±6.65</td><td>93.97 ± 2.34</td></tr><tr><td>pFedMe</td><td>49.87± 3.16</td><td>66.95 ± 10.65</td><td>69.00 ± 4.97</td><td>78.66± 3.72</td><td>94.57 ± 1.95</td></tr><tr><td>Ours (n=5)</td><td>77.823 ± 2.24</td><td>82.38 ±0.66</td><td>84.45 ± 0.21</td><td>85.050 ±0.13</td><td>95.55 ± 0.26</td></tr><tr><td>Ours (n=10)</td><td>79.59 ± 0.34</td><td>83.66 ± 0.72</td><td>84.35 ±0.38</td><td>85.534±0.53</td><td>95.55 ± 0.06</td></tr></table>
+
+Table 2: In-distribution federated accuracy with 15 clients, $100 \%$ participation, across heterogeneity levels (measured by EMD). FedFomo performs better than or competitively with existing methods.
+
+Personalized model weighting We next investigate FedFomo’s personalization by learning optimal client to client weights overtime, visualizing $_ { r }$ during training in Fig. 2. We depict clients with the same local data distributions next to each other (e.g. clients $0 , 1 , 2$ belong to distribution 0). Given the initial diagonal $_ { P }$ depicting equal weighting for all other clients, we hope FedFomo increases the weights of clients that belong to the same distribution, discovering the underlying partitions without knowledge of client datasets. In Fig 2a we show this for the 15 client 5 non-IID latent distribution setting on CIFAR-10 with 5 clients downloaded and $\varepsilon = 0 . 3$ (lighter $=$ higher weight). These default parameters adjust well to settings with more total clients (Fig 2b), and when we change the number of latent distributions (and IID-ness) in the federation (Fig 2c).
+
+![](images/11163b3b1ecefc4fa1f6593e41166e0098b2cf0fc23aec87438d2bc825114996.jpg)  
+Figure 1: Classification accuracy of FL frameworks with 100 clients over latent distributions.
+
+![](images/7f47ac027b15807606842610df58c1d54587576d2d00956552708bcc2c939958.jpg)  
+Figure 2: FedFomo client-to-client weights over time and across different FL settings. We reliably upweight clients with the same training and target distributions.
+
+Exploration with $\varepsilon$ and number of models downloaded $M$ To further understand FedFomo’s behavior and convergence in non-IID personalized settings with respect to limited download bandwidth capability, we conduct an ablation over $\varepsilon$ and $M$ , reporting results on the 15 client CIFAR-10 5-distribution setting in Fig. 3 over 100 training epochs. We did not find consistent correlation between $\varepsilon$ and model performance, although this is tied to $M$ inherently (expecting reduced variance with higher $M$ ). With fixed $\varepsilon$ , greater $M$ led to higher performance, as we can evaluate more models and identify the “correct” model-client assignments earlier on.
+
+![](images/c6d54cffec8ba688ac73baefae5d533aaf38be74aaf53cdc0f272faa2ff13d9e.jpg)  
+Figure 3: Ablations over $\varepsilon$ -greedy exploration and number of models downloaded on CIFAR-10.
+
+Out-of-local-distribution personalization We now consider the non-IID federated setting where each client optimizes for target distributions not the same as their local data distribution. Here, although a client may sufficiently train an adequate model for one domain, it has another target data distribution of interest with hard to access relevant data. For example, in a self-driving scenario, a client may not have enough data for certain classes due to geographical constraints, motivating the need to leverage info from others. To simulate this scenario, after organizing data into latent distributions, we randomly shuffle $( D ^ { \mathrm { v a l } } , D ^ { \mathrm { t e s t } } )$ as a pair among clients. We test on the CIFAR-10 and CIFAR-100 datasets with 15 clients, full participation, and 5 latent distributions, repeating the shuffling five times, and report mean accuracy over all clients.
+
+![](images/2d7be5976998521ed578a4082ec69aaf30924772c284b0cb44197535ef66c962.jpg)  
+Figure 4: Top Personalization on target distribution $\neq$ that of local training data. Bottom FedFomo upweights other clients with local data $\sim$ target distribution (5 latent non-IID dist.)
+
+Table 3: Out-of-client distribution evaluation with 5 latent distributions and 15 clients. FedFomo outperforms all alternatives in various datasets.   
+
+<table><tr><td></td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>Local Training</td><td>20.39 ± 3.36</td><td>7.40 ± 1.31</td></tr><tr><td>FedAvg</td><td>23.11 ± 2.51</td><td>13.06 ± 1.48</td></tr><tr><td>FedAvg + Data</td><td>42.15 ± 2.16</td><td>24.98 ± 4.98</td></tr><tr><td>FedProx</td><td>39.79 ± 8.57</td><td>14.39 ± 2.85</td></tr><tr><td>LG-FedAvg</td><td>38.95 ±1.85</td><td>18.50 ± 1.10</td></tr><tr><td>MOCHA</td><td>30.80 ± 2.60</td><td>13.73 ± 2.83</td></tr><tr><td>Clustered FL</td><td>29.73± 3.67</td><td>19.75 ± 1.58</td></tr><tr><td>Per-FedAvg</td><td>39.8 ± 5.38</td><td>21.30 ± 1.35</td></tr><tr><td>pFedMe</td><td>43.7 ± 7.27</td><td>25.41 ± 2.33</td></tr><tr><td>Ours (n=5)</td><td>64.06 ±2.80</td><td>34.43 ± 1.48</td></tr><tr><td>Ours (n=10)</td><td>63.98 ± 1.81</td><td>40.94±1.62</td></tr></table>
+
+As shown in Fig. 4 and Table 3, our method consistently strongly outperforms alternatives in both non-IID CIFAR-10 and CIFAR-100 federated settings. We compare methods using the same train and test splits randomly shuffled between clients, such that through shuffling we encounter potentially large amounts of data variation between a client’s training data and its test set. This then supports the validity of the validation split and downloaded model evaluation components in our method to uniquely optimize for arbitrary data distributions different from a client’s local training data. All methods other than ours are unable to convincingly handle optimizing for a target distribution that is different from the client’s initially assigned local training data. Sharing data expectedly stands out among other methods that do not directly optimize for a client’s objective, as each client then increases the label representation overlap between its train and test sets. We note that in the 2-distribution setting, where each client’s training data consists of 5 classes on average, the higher performance of other methods may likely be a result of our simulation, where with only two distributions to shuffle between it is more likely that more clients end up with the same test distribution.
+
+To shed further light on FedFomo’s performance, we visualize how client weights evolve over time in this setting (Fig. 4 bottom), where to effectively personalize for one client, FedFomo should specifically increase the weights for the other clients belonging to the original client’s target distribution. Furthermore, in the optimal scenario we should upweight all clients with this distribution while downweighting the rest. Here we show that this indeed seems to be the case, denoting local training distributions with color. We depict clients 12, 13, and 14, which all carry the same local data distribution, but 13 and 14 optimize for out-of-local distributions. In all cases, FedFomo upweights clients specifically carrying the same data distribution, such that while with shuffling we do not know apriori 13 and 14’s target distributions, FedFomo discovers these and who should federate with whom in this setting as well. We include similar plots for all clients in Appendix A.2 (Fig. 6).
+
+Locally Private FedFomo While we can implement FedFomo such that downloaded model parameters are inaccessible and any identifying connections between clients and their uploaded models are removed to subsequently preserve anonymity, unique real world privacy concerns may rise when sharing individual model parameters. Accordingly, we now address training FedFomo under $( \varepsilon , \delta )$ -differential privacy (DP). Dwork et al. (2014) present further details, but briefly DP ensures that given two near identical datasets, the probability that querying one produces a result is nearly the same as querying the other (under control by $\varepsilon$ and $\delta$ ). Particularly useful here are DP’s composability and robustness to post-processing, which ensure that if we train model parameters $\theta$ to satisfy DP, then any function on $\theta$ is also DP. We then perform local training with DP-SGD (Abadi et al., 2016) for a DP variant of FedFomo, which adds a tunable amount of Gaussian noise to each gradient and reduces the connection between a model update and individual samples in the local training data. More noise makes models more private at the cost of performance, and here we investigate if FedFomo retains its performance with increased privacy under noisy local updates.
+
+Table 4: In-distribution classification with differentially private federated learning. With DP-SGD, FedFomo maintains high personalization accuracy with reasonable privacy guarantees.   
+
+<table><tr><td></td><td></td><td></td><td colspan="2">CIFAR-10</td><td colspan="2">CIFAR-100</td></tr><tr><td>Method</td><td>8</td><td>0</td><td>ε</td><td>Accuracy</td><td>E</td><td>Accuracy</td></tr><tr><td>FedAvg</td><td>1×10-5</td><td>0</td><td>8</td><td>19.37 ± 1.42</td><td>8</td><td>5.09 ± 0.38</td></tr><tr><td>FedAvg</td><td>1×10-5</td><td>1</td><td>10.26 ± 0.21</td><td>17.60 ± 1.64</td><td>8.20 ± 0.69</td><td>5.05 ± 0.31</td></tr><tr><td>FedAvg</td><td>1×10-5</td><td>2</td><td>3.57 ± 0.08</td><td>16.19 ± 1.62</td><td>2.33 ± 0.21</td><td>4.33 ± 0.27</td></tr><tr><td>Ours</td><td>1×10-5</td><td>0</td><td>8</td><td>71.56 ± 1.20</td><td>8</td><td>26.76 ± 1.20</td></tr><tr><td>Ours</td><td>1×10-5</td><td>1</td><td>6.89 ± 0.13</td><td>71.28 ± 1.06</td><td>8.20±0.69</td><td>26.14 ± 1.05</td></tr><tr><td>Ours</td><td>1×10-5</td><td>2</td><td>1.70 ± 0.04</td><td>65.97 ± 0.95</td><td>1.71 ± 0.15</td><td>15.95 ± 0.94</td></tr></table>
+
+![](images/3dcaef7d7686c22db2e430b86eb759146d7f044ac81da97b7a8eb86251e84203.jpg)  
+Figure 5: Left: Even with privacy-preserving updates, FedFomo still uncovers the underlying data distributions at large. Right We gain privacy benefits without substantial drop in performance.
+
+We consider the in-distribution personalization task with 5 latent non-IID distributions from the CIFAR-10 and CIFAR-100 datasets, with 15 clients and full participation at each round, and compare FedFomo against FedAvg with varying levels of Gaussian noise, specified by $\sigma$ . With all other parameters fixed, higher $\sigma$ should enable more noisy updates and greater privacy (lower $\varepsilon$ ), at the potential cost of performance. At fixed $\delta$ , we wish to obtain high classification accuracy and low $\varepsilon$ . We use the Opacus Pytorch library2 for DP-SGD, and as baselines run FedFomo and FedAvg with the library’s provided SGD optimizer with $\sigma = 0$ . For DP runs, we set $\delta = 1 \times 1 0 ^ { - 5 } \ll 3 \times \mathrm { \bar { 1 0 ^ { - 4 } } }$ , the inverse of the average number of local data points of each client, to maintain reasonable privacy.
+
+In Table 4, FedFomo is able to retain a sizeable improvement over FedAvg, even against the nonDP FedAvg, and does so with minimal $\varepsilon$ . As expected, greater $\sigma$ leads to improved privacy (lower $\varepsilon$ ) at the cost of decreased performance. Additionally, in Fig. 5 we show that even with noisy gradients to protect individual data point privacy, FedFomo maintains its ability to discover the larger latent distributions among local data (albeit with more noise initially). Most importantly, despite adding noise that could potentially derail our federated update, we are able to substantially reduce privacy violation risks under $( \varepsilon , \delta )$ -differential privacy while maintaining strong performance.
+
+# 5 CONCLUSION
+
+We present FedFomo, a flexible personalized FL framework that achieves strong performance across various non-IID settings, and uniquely enables clients to also optimize for target distributions distinct from their local training data. To do so, we capture the intuition that clients should download personalized weighted combinations of other models based on how suitable they are towards the client’s own target objective, and propose a method to efficiently calculate such optimal combinations by downloading individual models in lieu of previously used model averages. Beyond outperforming alternative personalized FL methods, we empirically show that FedFomo is able to discover the underlying local client data distributions, and for each client specifically upweights the other models trained on data most aligned to the client’s target objective. We finally explore how our method behaves with additional privacy guarantees, and show that we can still preserve the core functionality of FedFomo and maintain strong personalization in federated settings.
+
+# REFERENCES
+
+Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pp. 308–318, 2016.
+
+Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecnˇ y, Stefano Mazzocchi, H Brendan McMahan, et al. Towards \` federated learning at scale: System design. arXiv preprint arXiv:1902.01046, 2019.
+
+Christopher Briggs, Zhong Fan, and Peter Andras. Federated learning with hierarchical clustering of local updates to improve training on non-iid data. arXiv preprint arXiv:2004.11791, 2020.
+
+Guobin Chen, Wongun Choi, Xiang Yu, Tony Han, and Manmohan Chandraker. Learning efficient object detection models with knowledge distillation. In Advances in Neural Information Processing Systems, pp. 742–751, 2017.
+
+Yuyang Deng, Mohammad Mahdi Kamani, and Mehrdad Mahdavi. Adaptive personalized federated learning. arXiv preprint arXiv:2003.13461, 2020.
+
+Cynthia Dwork, Aaron Roth, et al. The algorithmic foundations of differential privacy. Foundations and Trends in Theoretical Computer Science, 9(3-4):211–407, 2014.
+
+Alireza Fallah, Aryan Mokhtari, and Asuman Ozdaglar. Personalized federated learning: A metalearning approach. arXiv preprint arXiv:2002.07948, 2020.
+
+Avishek Ghosh, Jichan Chung, Dong Yin, and Kannan Ramchandran. An efficient framework for clustered federated learning. arXiv preprint arXiv:2006.04088, 2020.
+
+Filip Hanzely and Peter Richtarik. Federated learning of a mixture of global and local models. ´ arXiv preprint arXiv:2002.05516, 2020.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Thomas Hofmann. Latent semantic models for collaborative filtering. ACM Transactions on Information Systems (TOIS), 22(1):89–115, 2004.
+
+Kevin Hsieh, Amar Phanishayee, Onur Mutlu, and Phillip B Gibbons. The non-iid data quagmire of decentralized machine learning. arXiv preprint arXiv:1910.00189, 2019.
+
+Tzu-Ming Harry Hsu, Hang Qi, and Matthew Brown. Measuring the effects of non-identical data distribution for federated visual classification. arXiv preprint arXiv:1909.06335, 2019.
+
+Yihan Jiang, Jakub Konecnˇ y, Keith Rush, and Sreeram Kannan. Improving federated learning per- \` sonalization via model agnostic meta learning. arXiv preprint arXiv:1909.12488, 2019.
+
+Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurelien Bellet, Mehdi Bennis, Arjun Nitin ´ Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. Proceedings of Machine Learning and Systems, 2:429–450, 2020.
+
+Paul Pu Liang, Terrance Liu, Liu Ziyin, Ruslan Salakhutdinov, and Louis-Philippe Morency. Think locally, act globally: Federated learning with local and global representations. arXiv preprint arXiv:2001.01523, 2020.
+
+Yishay Mansour, Mehryar Mohri, Jae Ro, and Ananda Theertha Suresh. Three approaches for personalization with applications to federated learning. arXiv preprint arXiv:2002.10619, 2020.
+
+Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial Intelligence and Statistics, pp. 1273–1282. PMLR, 2017.
+
+H. Brendan McMahan, Eider Moore, Daniel Ramage, and Blaise Aguera y Arcas. Federated learning ¨ of deep networks using model averaging. CoRR, abs/1602.05629, 2016. URL http://arxiv. org/abs/1602.05629.
+
+Daniel Peterson, Pallika Kanani, and Virendra J Marathe. Private federated learning with domain adaptation. arXiv preprint arXiv:1912.06733, 2019.
+
+Felix Sattler, Klaus-Robert Muller, and Wojciech Samek. Clustered federated learning: Model- ¨ agnostic distributed multitask optimization under privacy constraints. IEEE Transactions on Neural Networks and Learning Systems, 2020.
+
+Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet Talwalkar. Federated multi-task learning. CoRR, abs/1705.10467, 2017. URL http://arxiv.org/abs/1705.10467.
+
+Canh T Dinh, Nguyen Tran, and Tuan Dung Nguyen. Personalized federated learning with moreau envelopes. Advances in Neural Information Processing Systems, 33, 2020.
+
+Kangkang Wang, Rajiv Mathews, Chloe Kiddon, Hubert Eichner, Franc¸oise Beaufays, and Daniel ´ Ramage. Federated evaluation of on-device personalization. arXiv preprint arXiv:1910.10252, 2019.
+
+Yuhui Xu, Yongzhuang Wang, Aojun Zhou, Weiyao Lin, and Hongkai Xiong. Deep neural network compression with single and multiple level quantization. arXiv preprint arXiv:1803.03289, 2018.
+
+Yue Zhao, Meng Li, Liangzhen Lai, Naveen Suda, Damon Civin, and Vikas Chandra. Federated learning with non-iid data. CoRR, abs/1806.00582, 2018. URL http://arxiv.org/abs/ 1806.00582.
+
+# A APPENDIX
+
+# A.1 DERIVING THE FOMO UPDATE
+
+Recall that we can view each federated model download can be viewed as an iterative update,
+
+$$
+\theta _ { i } ^ { \ell ( t + 1 ) } = \theta _ { i } ^ { \ell ( t ) } + \sum _ { n = 1 } ^ { N } w _ { n } \cdot \big ( \theta _ { n } ^ { \ell ( t ) } - \theta _ { i } ^ { \ell ( t ) } \big )
+$$
+
+where given a client’s current parameters $\theta _ { i } ^ { \ell ( t ) }$ , the weights $\pmb { w } = \langle w _ { 1 } , \dots , w _ { N } \rangle$ in conjunction with the model deltas (t)−θ\`(t)i determine how much each client should move its local model parameters to optimize for some objective. Unlike more common methods in machine learning such as gradient descent, the paths we can take to get to this objective are restricted by the fixed model parameters $\{ \theta _ { n } ^ { \ell ( t ) } \}$ available to us at time $t$ . While traditional FL methods presume this objective to be global test set performance, from a client-centric perspective we should be able to set this objective with respect to any dataset or target distribution of interest.
+
+We then view this problem as a constrained optimization problem where $\begin{array} { r } { \sum _ { n \in [ N ] } w _ { n } = 1 } \end{array}$ . As a small discrepancy, if $i \in [ N ]$ , then to also calculate $w _ { i }$ or how much client $c _ { i }$ should weigh its own model in the federated update directly, we reparameterize Eq. 4 as an update from a version of the local model prior to its current state, e.g.
+
+$$
+\theta _ { i } ^ { \ell ( t + 1 ) } = \theta _ { i } ^ { \ell ( t - 1 ) } + \sum _ { n = 1 } ^ { N } w _ { n } \cdot \big ( \theta _ { n } ^ { \ell ( t ) } - \theta _ { i } ^ { \ell ( t - 1 ) } \big )
+$$
+
+and again we have current budget of 1 to allocate to all weights $\pmb { w }$ . Additionally, to go along with Eq. 5, we deviate a bit from the optimal $t + 1$ term in Eq. 2 and set
+
+$$
+\boldsymbol { \theta } _ { i } ^ { \ell ( t + 1 ) } = \boldsymbol { \theta } _ { i } ^ { \ell ( t ) } \gets \boldsymbol { \theta } _ { i } ^ { \ell ( t - 1 ) } - \alpha \mathbf { 1 } ^ { \top } \nabla _ { w } \mathcal { L } _ { i } ( \boldsymbol { \theta } _ { i } ^ { \ell ( t - 1 ) } )
+$$
+
+There is then a parallel structure between Eq. 5 and Eq. 6, and we proceed by trying to find optimal $\pmb { w }$ that would let our update in Eq. 6 closely approximate the optimal update taking the gradient $\nabla _ { w }$ . We accordingly note the equivalence from Eq. 5 and Eq. 6, where for desired $w _ { n }$ ,
+
+$$
+\sum _ { n = 1 } ^ { N } w _ { n } \cdot \big ( \theta _ { n } ^ { \ell ( t ) } - \theta _ { i } ^ { \ell ( t - 1 ) } \big ) = - \alpha \mathbf { 1 } ^ { \top } \nabla _ { w } \mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } )
+$$
+
+or in matrix form:
+
+$$
+\left[ \begin{array} { c } { w _ { 1 } } \\ { \vdots } \\ { w _ { N } } \end{array} \right] ^ { \top } \left[ \begin{array} { c } { ( \theta _ { 1 } ^ { \ell ( t ) } - \theta _ { i } ^ { \ell ( t - 1 ) } ) } \\ { \vdots } \\ { ( \theta _ { N } ^ { \ell ( t ) } - \theta _ { i } ^ { \ell ( t - 1 ) } ) } \end{array} \right] = \left[ \begin{array} { c } { - \alpha } \\ { \vdots } \\ { - \alpha } \end{array} \right] ^ { \top } \left[ \begin{array} { c } { \frac { \partial } { \partial w _ { 1 } } \mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } ) } \\ { \vdots } \\ { \frac { \partial } { \partial w _ { N } } \mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } ) } \end{array} \right]
+$$
+
+Then for each weight $w _ { n }$ , we solve for its optimal value by equating the left and right-hand corresponding vector components. We do so by deriving a first order approximation of $\begin{array} { r l r }   { \bar { \partial } \ } & { { } } & { \textstyle \mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } ) } \end{array}$ First, for each $w _ { n }$ , we define the function:
+
+$$
+\varphi _ { n } ( w ) : = w _ { n } \cdot \theta _ { n } ^ { \ell ( t ) } + ( 1 - w _ { n } ) \cdot \theta _ { i } ^ { \ell ( t - 1 ) }
+$$
+
+as an alternate parameterization of the $\theta$ ’s as functions of weights. We can see that for all $n \in [ N ]$ ,
+
+$$
+\begin{array} { c } { { \varphi _ { n } ( 0 ) = \theta _ { i } ^ { \ell ( t - 1 ) } } } \\ { { \Rightarrow \ \displaystyle \frac { \partial } { \partial w _ { n } } { \mathcal { L } } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } ) = \displaystyle \frac { \partial } { \partial w _ { n } } { \mathcal { L } } _ { i } ( \varphi _ { n } ( 0 ) ) } } \end{array}
+$$
+
+Then using a first-order Taylor series approximation, we also note that
+
+$$
+\mathcal { L } _ { i } ( \varphi _ { n } ( w ^ { \prime } ) ) \approx \mathcal { L } _ { i } ( \varphi _ { n } ( 0 ) ) + \frac { \partial } { \partial w _ { n } } \mathcal { L } _ { i } ( \varphi _ { n } ( 0 ) ) ( w ^ { \prime } - 0 )
+$$
+
+such ur initial point $w = 0$ or $\theta _ { i } ^ { \ell ( t - 1 ) }$ , we can approximate the derivative $\frac { \partial } { \partial w _ { n } } \mathcal { L } _ { i } ( \varphi _ { n } ( 0 ) )$ $w ^ { \prime } = 1$
+
+$$
+\begin{array} { r l r } & { } & { \frac { \partial } { \partial w _ { n } } \mathcal { L } _ { i } ( \varphi _ { n } ( 0 ) ) = \mathcal { L } _ { i } ( \varphi _ { n } ( 1 ) ) - \mathcal { L } _ { i } ( \varphi _ { n } ( 0 ) ) } \\ & { } & { \Rightarrow \frac { \partial } { \partial w _ { n } } \mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } ) = \mathcal { L } _ { i } ( \theta _ { n } ^ { \ell ( t ) } ) - \mathcal { L } _ { i } ( \theta _ { i } ^ { \ell ( t - 1 ) } ) } \end{array}
+$$
+
+following from Eq. 9. Then for each vector element in Eq. 8, indexed by $n = [ N ]$ , we can plug in the corresponding partial derivative from Eq. 11 and solve for the corresponding $w _ { n }$ to get
+
+$$
+w _ { n } = - \alpha \cdot \frac { \mathcal { L } _ { i } ( \boldsymbol { \theta } _ { n } ^ { \ell ( t ) } ) - \mathcal { L } _ { i } ( \boldsymbol { \theta } _ { i } ^ { \ell ( t - 1 ) } ) } { \Vert \boldsymbol { \theta } _ { n } ^ { \ell ( t ) } - \boldsymbol { \theta } _ { i } ^ { \ell ( t - 1 ) } \Vert }
+$$
+
+as the individual weight for client $c _ { i }$ to weight model $\theta _ { n }$ in its federated update.
+
+We arrive at Eq. 3 by distributing the negative $\alpha$ to capture the right direction in each update, but also note that the constant cancels out because we normalize to ensure our weights sum to 1, such that the weights $w _ { n } ^ { * }$ that we actually use in practice are given by:
+
+$$
+w _ { n } ^ { * } = \frac { \operatorname* { m a x } ( w _ { n } , 0 ) } { \sum _ { n = 1 } ^ { N } \operatorname* { m a x } ( w _ { n } , 0 ) }
+$$
+
+# A.2 ADDITIONAL LATENT DISTRIBUTION NON-IID EXPERIMENTS
+
+CIFAR-100 Here we show results on the latent non-IID in-distribution personalization setup for the CIFAR-100 dataset. As in the CIFAR-10 setting, we compare FedFomo against various recent alternative methods when personalizing to a target distribution that is the same as the client’s local training data, and report accuracy as an average over all client runs. We also show results partitioning the CIFAR-100 dataset into increasing number of data distributions for 15 clients total, and report the increasing EMD in parentheses. In Table 5, FedFomo consistently outperforms all alternatives with more non-IID data across different clients. We note similar patterns to that of the CIFAR-10 dataset, where our method is more competitive when client data is more similar (lower EMD, number of distributions), but handily outperforms others as we increase this statistical label heterogeneity.
+
+Table 5: In-distribution personalized federated classification on the CIFAR-100 dataset   
+
+<table><tr><td colspan="6">CIFAR-100 Number of Latent Distributions (EMD)</td></tr><tr><td>Method</td><td>2 (1.58)</td><td>3 (1.96)</td><td>4 (2.21)</td><td>5 (2.41)</td><td>10 (2.71)</td></tr><tr><td>Local Training</td><td>23.36 ± 0.33</td><td>23.89 ± 2.03</td><td>28.44 ±1.97</td><td>23.11 ± 9.44</td><td>41.26 ±1.31</td></tr><tr><td>FedAvg</td><td>28.01±0.74</td><td>18.95 ±0.22</td><td>25.69 ± 0.41</td><td>21.26 ±0.89</td><td>18.19 ± 0.987</td></tr><tr><td>FedAvg + Data</td><td>28.12 ± 0.63</td><td>19.01 ± 0.27</td><td>25.85 ± 0.27</td><td>25.18 ±0.39</td><td>18.23 ± 0.835</td></tr><tr><td>FedProx</td><td>28.21±0.79</td><td>27.78 ± 0.000</td><td>25.79 ± 0.05</td><td>24.93 ±0.38</td><td>18.18 ±0.82</td></tr><tr><td>LG-FedAvg</td><td>26.97 ± 7.52</td><td>24.69 ± 4.29</td><td>24.79 ± 4.50</td><td>25.62 ± 5.70</td><td>27.53 ± 9.12</td></tr><tr><td>MOCHA</td><td>33.66 ± 4.14</td><td>33.61 ± 7.88</td><td>29.44± 8.30</td><td>32.34± 7.09</td><td>34.72 ± 7.80</td></tr><tr><td>Clustered FL</td><td>41.50 ±6.66</td><td>36.36 ±10.72</td><td>37.41 ± 8.30</td><td>36.78 ±12.05</td><td>34.43 ± 10.14</td></tr><tr><td>Per-FedAvg</td><td>32.14 ± 6.90</td><td>32.22 ± 7.37</td><td>34.50 ± 5.81</td><td>36.58 ± 6.72</td><td>38.41 ± 7.41</td></tr><tr><td>pFedMe</td><td>31.53 ± 3.83</td><td>32.39 ± 5.36</td><td>30.86 ± 3.75</td><td>30.86 ± 3.80</td><td>37.70 ± 2.13</td></tr><tr><td>Ours (n=5)</td><td>35.44 ± 1.91</td><td>36.21 ± 4.92</td><td>38.41 ± 2.58</td><td>42.96 ± 1.24</td><td>44.29 ±1.22</td></tr><tr><td>Ours (n=10)</td><td>37.09 ± 1.95</td><td>37.09 ± 3.84</td><td>39.94 ± 0.74</td><td>43.06 ±0.42</td><td>43.75 ±1.74</td></tr></table>
+
+# A.3 CLIENT WEIGHTING WITH PERSONALIZATION
+
+In-local vs out-of-local distribution personalization Following the visualizations for client weights in the out-of-local distribution personalization setting (Fig. 4), we include additional visualizations for the remaining clients (Fig. 6). For comparison, we also include the same visualizations for the 15 client 5 non-IID latent distribution setup on CIFAR-10, but when clients optimize for a target distribution the same as their local training data’s (Fig. 7). In both, we use color to denote the client’s local training data distribution, such that if FedFomo is able to identify the right clients to federated with that client, we should see the weights for those colors increase or remain steady over federation rounds, while all other client weights drop.
+
+As seen in both Fig. 6 and Fig. 7, FedFomo quickly downweights clients with unhelpful data distributions. For the in-distribution personalization, it is able to increase and maintain higher weights for the clients from the same distribution, and consistently does so for the other two clients that belong to its distribution. In the out-of-local distribution personalization setting, due to our shuffling procedure we have instances where certain clients have in-distribution targets, while others have out-of-distribution targets. We see that FedFomo is able to accommodate both simultaneously, and learns to separate all clients belonging to the target distributions of each client from the rest.
+
+![](images/e92a2b61f23f7bdb781a93d0919396109e85a5e53fddc5703dc39d88ad226aa5.jpg)  
+Figure 6: Client-to-client weights over time when personalizing for non-local target distributions. FedFomo quickly downweights non-relevant clients while upweighting those that are helpful.
+
+![](images/ecf631e6902193b8ec61d4225d519a2c03f95ef37d8df24ff848b72538c15462.jpg)  
+Figure 7: Client-to-client weights over time when personalizing for local target distributions. FedFomo downweights non-relevant clients while upweighting or keeping steady helpful ones.
+
+<table><tr><td></td><td></td><td></td><td colspan="2">CIFAR-10</td><td colspan="2">CIFAR-100</td></tr><tr><td>Method</td><td>8</td><td>0</td><td>m</td><td>Accuracy</td><td>m</td><td>Accuracy</td></tr><tr><td>FedAvg</td><td>1 ×10-5</td><td>0</td><td>8</td><td>19.37 ± 1.42</td><td>8</td><td>5.09 ± 0.38</td></tr><tr><td>FedAvg</td><td>1×10-5</td><td>1</td><td>10.26 ± 0.21</td><td>17.60 ± 1.64</td><td>8.20± 0.69</td><td>5.05 ± 0.31</td></tr><tr><td>FedAvg</td><td>1×10-5</td><td>2</td><td>3.57 ± 0.08</td><td>16.19 ± 1.62</td><td>2.33± 0.21</td><td>4.33 ± 0.27</td></tr><tr><td>Ours</td><td>1×10-5</td><td>0</td><td>8</td><td>71.56 ± 1.20</td><td>8</td><td>26.76 ± 1.20</td></tr><tr><td>Ours</td><td>1×10-5</td><td>1</td><td>6.89 ± 0.13</td><td>71.28 ± 1.06</td><td>8.20±0.69</td><td>26.14 ± 1.05</td></tr><tr><td>Ours</td><td>1×10-5</td><td>2</td><td>1.70 ± 0.04</td><td>65.97 ± 0.95</td><td>1.71 ± 0.15</td><td>15.95 ± 0.94</td></tr><tr><td>Ours (MA)</td><td>1×10-5</td><td>0</td><td>8</td><td>47.90 ± 2.79</td><td>8</td><td>12.02 ± 1.34</td></tr><tr><td>Ours (MA)</td><td>1×10-5</td><td>1</td><td>9.26 ±0.19</td><td>46.33 ± 4.04</td><td>10.32 ± 0.89</td><td>11.60 ± 0.65</td></tr><tr><td>Ours (MA)</td><td>1×10-5</td><td>2</td><td>3.20 ± 0.07</td><td>43.76 ± 3.08</td><td>3.22 ± 0.28</td><td>9.52 ± 0.72</td></tr></table>
+
+Table 6: In-distribution classification with differentially private federated learning, with the addition of FedFomo with a model average baseline (Ours (MA)).
+
+# A.4 ADDITIONAL PRIVACY EXPERIMENTS
+
+As a follow-up on the privacy experiments in Section 4, we also consider a multiple model variant of FedFomo, where instead of a client downloading a single model $\theta _ { n }$ and evaluating against its own previous model $\theta _ { i } ^ { t - 1 }$ , the client downloads the simple average of all the uploaded models except $\theta _ { n }$ (i.e. $\begin{array} { r } { \frac { 1 } { N - 1 } \sum _ { j \in [ N ] \setminus n } \theta _ { n } ) } \end{array}$ and compares this against the simple average of all uploaded models. This tackles an orthogonal notion of privacy compared to the previous solution of introducing noise to local model gradients via DP-SGD, as now individual data point membership is harder to distill from shared parameters that come from the average of multiple local models. To calculate weights, we note a sign change with respect to Eq. 3 and the baseline model, as now $w _ { n }$ should be positive if the model average without $\theta _ { n }$ ’s contribution results in a larger target objective loss than the model average with $\theta _ { n }$ . Given client $c _ { i }$ considering model $\theta _ { n }$ , this leads to FedFomo weights:
+
+$$
+w _ { n } \propto \mathscr { L } _ { i } \Big ( \frac { 1 } { N - 1 } \sum _ { j \in [ N ] \backslash n } \theta _ { j } \Big ) - \mathscr { L } _ { i } \Big ( \frac { 1 } { N } \sum _ { j \in [ N ] } \theta _ { j } \Big )
+$$
+
+We evaluate this variant with the same comparison over $( \varepsilon , \delta )$ -differential privacy parameters on the 15 client 5 latent-distribution scenarios in our previous privacy analysis. We set $\mathbf { \bar { \delta } } ( \delta = 1 \times 1 0 ^ { - 5 }$ to setup practical privacy guarantees with respect to the number of datapoints in each client’s local training set, and consider Gaussian noise $\sigma \in \{ 0 , 1 , 2 \}$ for baseline and $( \varepsilon , \delta )$ -differentially private performances. At fixed $\delta$ , we wish to obtain high classification accuracy with low privacy loss $( \varepsilon )$ .
+
+In Table 6 we include results for this model average baseline variant (Ours (MA)) on the CIFAR-10 and CIFAR-100 datasets, along with the differentially private federated classification results in Table 4 using DP-SGD during local training for additional context. For both datasets, we still handily outperform non-private FedAvg, although performance drops considerably with respect to the single model download FedFomo variant. We currently hypothesize that this may be due to a more noisy calculation of another model’s potential contribution to the client’s current model, as we now consider the effects of many more models in our loss comparisons as well. Figuring out a balance between the two presented weighting schemas to attain high personalization and high privacy by downloading model averages then remains interesting future work.
+
+# A.5 LATENT DISTRIBUTION NON-IID MOTIVATION AND SETUP
+
+In this subsection, we discuss our latent distribution non-IID setting in more detail. We believe the pathological setup though useful might not represent more realistic or frequent occurring setups. As an example, a world-wide dataset of road landscapes may vary greatly across different data points, but variance in their feature representations can commonly be explained by their location. In another scenario, we can imagine that certain combinations of songs, or genres of music altogether are more likely to be liked by the same person than others. In fact, the very basis and success of popular recommender system algorithms such as collaborative filtering and latent factor models rely on this scenario (Hofmann, 2004). Accordingly, in this sense statistical heterogeneity and client local data non-IIDnes is more likely to happen in groups.
+
+We thus propose and utilize a latent distribution method to evaluate FedFomo against other more recent proposed FL work. To use this setting, we first compute image representations by training a VGG-11 convolutional neural network to at least $8 5 \%$ classification accuracy on a corresponding dataset. We then run inference on every data point, and treat the 4096-dimensional vector produced in the second fully-connected layer as a semantic embedding for each individual image. After further reduction to 256 dimensions through PCA, we use K-Means clustering to partition our dataset into $D$ disjoint distributions. Given $K$ total clients, we then evenly assign each client to a distribution $\mathcal { D }$ . For each client we finally obtain its local data by sampling randomly from $\mathcal { D }$ without replacement. For datasets with pre-defined train and test splits, we cluster embeddings from both at the same time such that similar images across splits are assigned the same K-means cluster, and respect these original splits such that all ${ \pmb { D } } ^ { \mathrm { t e s t } }$ images come from the original test split. (Fig. 8)
+
+![](images/c75efe3846c2cadce90f040b7f2f8e824e4e2ed1a2fab1c9007b17705d295e62.jpg)  
+Figure 8: Visual overview for generating latent distributions using image classification datasets.
+
+# A.6 MODEL IMPLEMENTATION DETAILS
+
+We train with SGD, 0.1 learning rate, 0 momentum, 1e-4 weight decay, and 0.99 learning rate decay for CIFAR-10/100, and do the same except with 0.01 learning rate for MNIST. For FedFomo we use $n = 5$ and $n = 1 0$ downloads per client, $\varepsilon = 0 . 3$ with 0.05 decay each round, and separate $D ^ { \mathrm { t r a i n } }$ and $D ^ { \mathrm { v a l } }$ with an 80-20 split.
+
+# A.7 ADDITIONAL DESIGN ABLATIONS
+
+In this section we present additional work on key hyperparameters or aspects of FedFomo to give further insight into our method’s functionality and robustness to parameters. We consider key design choices related to the size of each client’s validation split.
+
+Size of the validation split To better organize federated uploaded models into personalized federated updates, our method requires a local validation split $\bar { D ^ { \mathrm { v a l } } }$ that reflects the client’s objective or target test distribution. Here, given a pre-defined amount of locally available data, we ask the natural question of how a client should best go about dividing its data points between those to train its own local model and those to evaluate others with respect to computing a more informed personalized update through FedFomo. We use the 15 client $1 \bar { 0 } 0 \%$ participation setup with 5 latent distributions organized over the CIFAR-10 dataset, and consider both the evaluation curve and final test accuracy over allocating a fraction $\in \{ 0 . 0 1 , 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 4 , 0 . 6 , 0 . 8 , 0 . 9 \}$ of all clients’ local data to $D ^ { \mathrm { v a l } }$ , and track evaluation over 20 communication rounds with 5 epochs of local training per round. On average, each client has 3333 local data points. We denote final accuracy and standard deviation over five runs in Fig 9.
+
+![](images/4485453982698e7c11a8a86286282ca3c64ab55455563e810dd009841c720e80.jpg)  
+Figure 9: In-distribution accuracy over validation split ratio.
+
+As reported in Fig. 9, we observe faster convergence to a higher accuracy when allocating under half of all local data points to the validation split, with a notable drop-off using more data points. This is most likely a result of reducing the amount of data available for each client to train their model locally. Eventually this stagnates, and observe a slight decrease in performance between validation split fraction 0.05 and 0.1.

parse/train/mgVbI13p96/mgVbI13p96.md

@@ -0,0 +1,407 @@
+# MULTI-MODAL SELF-SUPERVISION FROM GENERALIZED DATA TRANSFORMATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In the image domain, excellent representations can be learned by inducing invariance to content-preserving transformations, such as image distortions. In this paper, we show that, for videos, the answer is more complex, and that better results can be obtained by accounting for the interplay between invariance, distinctiveness, multiple modalities, and time. We introduce Generalized Data Transformations (GDTs) as a way to capture this interplay. GDTs reduce most previous selfsupervised approaches to a choice of data transformations, even when this was not the case in the original formulations. They also allow to choose whether the representation should be invariant or distinctive w.r.t. each effect and tell which combinations are valid, thus allowing us to explore the space of combinations systematically. We show in this manner that being invariant to certain transformations and distinctive to others is critical to learning effective video representations, improving the state-of-the-art by a large margin, and even surpassing supervised pretraining. We demonstrate results on a variety of downstream video and audio classification and retrieval tasks, on datasets such as HMDB-51, UCF-101, DCASE2014, ESC-50 and VGG-Sound. In particular, we achieve new state-ofthe-art accuracies of $7 2 . 8 \%$ on HMDB-51 and $9 5 . 2 \%$ on UCF-101.
+
+# 1 INTRODUCTION
+
+Recent works such as PIRL (Misra & van der Maaten, 2020), MoCo (He et al., 2019) and SimCLR (Tian et al., 2019) have shown that it is possible to pre-train state-of-the-art image representations without the use of any manually-provided labels. Furthermore, many of these approaches use variants of noise contrastive learning (Gutmann & Hyvärinen, 2010). Their idea is to learn a representation that is invariant to transformations that leave the meaning of an image unchanged (e.g. geometric distortion or cropping) and distinctive to changes that are likely to alter its meaning (e.g. replacing an image with another chosen at random).
+
+An analysis of such works shows that a dominant factor for performance is the choice of the transformations applied to the data. So far, authors have explored ad-hoc combinations of several transformations (e.g. random scale changes, crops, or contrast changes). Videos further allow to leverage the time dimension and multiple modalities. For example, Arandjelovic & Zisserman (2017); Owens et al. (2016) learn representations by matching visual and audio streams, as a proxy for objects that have a coherent appearance and sound. Their formulation is similar to noise contrastive ones, but does not quite follow the pattern of expressing the loss in terms of data transformations. Others (Chung & Zisserman, 2016; Korbar et al., 2018; Owens & Efros, 2018) depart further from standard contrastive schemes by learning representations that can tell whether visual and audio streams are in sync or not; the difference here is that the representation is encouraged to be distinctive rather than invariant to a time shift.
+
+Overall, it seems that finding an optimal noise contrastive formulation for videos will require combining several transformations while accounting for time and multiple modalities, and understanding how invariance and distinctiveness should relate to the transformations. However, the ad-hoc nature of these choices in previous contributions make a systematic exploration of this space rather difficult.
+
+In this paper, we propose a solution to this problem by introducing the Generalized Data Transformations (GDT; fig. 1) framework. GDTs reduce most previous methods, contrastive or not, to a noise contrastive formulation that is expressed in terms of data transformations only, making it simpler to systematically explore the space of possible combinations. This is true in particular for multi-modal data, where separating different modalities can also be seen as a transformation of an input video. The formalism also shows which combinations of different transformations are valid and how to enumerate them. It also clarifies how invariance and distinctiveness to different effects can be incorporated in the formulation and when doing so leads to a valid learning objective. These two aspects allows the search space of potentially optimal transformations to be significantly constrained, making it amenable to grid-search or more sophisticated methods such as Bayesian optimisation.
+
+![](images/951bd7ff1c3745544cb07ac7e574074b4b7912e035073949070fd954e77d338b.jpg)
+
+![](images/12003b64700cf518f28415cab976614b882eac9a7b5185224da356122819296c.jpg)
+
+![](images/afe038ef08e7e0db67328dcc7151856506152ea4fee70c40cd1b89b3080ad040.jpg)  
+Fig. 1: Schematic overview of our framework. A: Hierarchical sampling process of generalized transformations $T = t _ { M } \circ \dots \circ t _ { 1 }$ for the multi-modal training study case. B: Subset of the $c ( T , T ^ { \prime } )$ contrast matrix which shows which pairs are repelling (0) and attracting (1) (see text for details). C: With generalized data transformations (GDT), the network learns a meaningful embedding via learning desirable invariances and distinctiveness to transformations (realigned here for clarity) across modalities and time. The embedding is learned via noise contrastive estimation against clips of other source videos. Illustrational videos taken from YouTube (Google, 2020).
+
+By using GDTs, we make several findings. First, we find that using our framework, most previous pretext representation learning tasks can be formulated in a noise-contrastive manner, unifying previously distinct domains. Second, we show that just learning representations that are invariant to more and more transformations is not optimal, at least when it comes to video data; instead, balancing invariance to certain factors with distinctiveness to others performs best. Third, we find that by investigating what to be variant to can lead to large gains in downstream performances, for both visual and audio tasks.
+
+With this, we are able to set the new state of the art in audio-visual representation learning, with both small and large video pretraining datasets on a variety of visual and audio downstream tasks. In particular, we achieve $9 \bar { 5 } . 2 \%$ and $\mathrm { 7 2 . 8 \% }$ on the standardized UCF-101 and HMDB-51 action recognition benchmarks.
+
+# 2 RELATED WORK
+
+Self-supervised learning from images and videos. A variety of pretext tasks have been proposed to learn representations from unlabelled images. Some tasks leverage the spatial context in images (Doersch et al., 2015; Noroozi & Favaro, 2016) to train CNNs, while others create pseudo classification labels via artificial rotations (Gidaris et al., 2018), or clustering features (Asano et al., 2020b; Caron et al., 2018; 2019; Gidaris et al., 2020; Ji et al., 2018). Colorization (Zhang et al., 2016; 2017), inpainting (Pathak et al., 2016), solving jigsaw puzzles (Noroozi et al., 2017), as well as the contrastive methods detailed below, have been proposed for self-supervised image representation learning. Some of the tasks that use the space dimension of images have been extended to the space-time dimensions of videos by crafting equivalent tasks. These include jigsaw puzzles (Kim et al., 2019), and predicting rotations (Jing & Tian, 2018) or future frames (Han et al., 2019). Other tasks leverage the temporal dimension of videos to learn representations by predicting shuffled frames (Misra et al., 2016), the direction of time (Wei et al., 2018), motion (Wang et al., 2019), clip and sequence order (Lee et al., 2017; Xu et al., 2019), and playback speed (Benaim et al., 2020; Cho et al., 2020; Fernando et al., 2017). These pretext-tasks can be framed as GDTs.
+
+Multi-modal learning. Videos, unlike images, are a rich source of a variety of modalities such as speech, audio, and optical flow, and their correlation can be used as a supervisory signal. This idea has been present as early as 1993 (de Sa, 1994). Only recently, however, has multi-modal learning been used to successfully learn effective representations by leveraging the natural correspondence (Alwassel et al., 2020; Arandjelovic & Zisserman, 2017; Asano et al., 2020a; Aytar et al., 2016; Morgado et al., 2020; Owens et al., 2016) and synchronization (Chung & Zisserman, 2016; Korbar et al., 2018; Owens & Efros, 2018) between the audio and visual streams. A number of recent papers have leveraged speech as a weak supervisory signal to train video representations (Li & Wang, 2020; Miech et al., 2020; Nagrani et al., 2020; Sun et al., 2019a;b) and recently Alayrac et al. (2020), which uses speech, audio and video. Other works incorporate optical flow and other modalities (Han et al., 2020; Liu et al., 2019; Piergiovanni et al., 2020; Zhao et al., 2019) to learn representations. In (Tian et al., 2019), representations are learned with different views such as different color channels or modalities) to induce invariances. In contrast, our work analyses multi-modal transformations and examines their utility when used as an invariant or variant learning signal.
+
+Noise Contrastive Loss. Noise contrastive losses (Gutmann & Hyvärinen, 2010; Hadsell et al., 2006) measure the similarity between sample pairs in a representational space and are at the core of several recent works on unsupervised feature learning. It has been shown to yield good performance for learning image (Chen et al., 2020b; He et al., 2019; Hénaff et al., 2019; Hjelm et al., 2019; Li et al., 2020; Misra & van der Maaten, 2020; Oord et al., 2018; Tian et al., 2019; 2020; Wu et al., 2018) and video (Han et al., 2019; Li & Wang, 2020; Miech et al., 2020; Morgado et al., 2020; Sohn, 2016; Sun et al., 2019a) representations, and circumvents the need to explicitly specify what information needs to be discarded via a designed task.
+
+We leverage the noise contrastive loss as a learning framework to encourage the network to learn desired invariance and distinctiveness to data transformations. The GDT framework can be used to combine and extend many of these cues, contrastive or not, in a single noise contrastive formulation.
+
+# 3 METHOD
+
+A data representation is a function $f : \mathcal { X } \to \mathbb { R } ^ { D }$ mapping data points $x$ to vectors $f ( x )$ . Representations are useful because they help to solve tasks such as image classification. Based on the nature of the data and the task, we often know a priori some of the invariances that the representation should possess (for example, rotating an image usually does not change its class). We can capture those by means of the contrast function1 $c ( x _ { 1 } , x _ { 2 } ) = \delta _ { f ( x _ { 1 } ) = f ( x _ { 2 } ) }$ , where $c ( x _ { 1 } , x _ { 2 } ) = 1$ means that $f$ is invariant to substituting $x _ { 2 }$ for $x _ { 1 }$ , while $c ( x _ { 1 } , x _ { 2 } ) = 0$ means that $f$ is distinctive to this change. Any partial knowledge of the contrast $c$ can be used as a cue to learn $f$ , but $c$ is not arbitrary: in order for $c$ to be valid, the expression $c ( x _ { 1 } , x _ { 2 } ) ~ = ~ 1$ must be an equivalence relation on $\mathcal { X }$ , i.e. be reflexive $c ( x , x ) = 1$ , symmetric $c ( x _ { 1 } , x _ { 2 } ) = c ( x _ { 2 } , x _ { 1 } )$ and transitive $c ( x _ { 1 } , x _ { 2 } ) = c ( x _ { 2 } , x _ { 3 } ) = 1 \Rightarrow c ( x _ { 1 } , x _ { 3 } ) = 1$ . This is justified in Appendix A.1 and will be important in establishing which particular learning formulations are valid and which are not.
+
+We introduce next our Generalized Data Transformations (GDTs) framework by generalizing two typical formulations: the first is analogous to ‘standard’ methods such as MoCo (He et al., 2019) and SimCLR (Chen et al., 2020b) and the second tackles multi-modal data.
+
+Standard contrastive formulation. Recall that the goal is to learn a function $f$ that is compatible with a known contrast $c$ , in the sense explained above. In order to learn $f$ , we require positive $( c ( x _ { 1 } , x _ { 2 } ) = 1 )$ and negative $( c ( x _ { 1 } , x _ { 2 } ) = 0 )$ ) example pairs $( x _ { 1 } , x _ { 2 } )$ . We generate positive pairs by sampling $x _ { 1 }$ from a data source and then by setting $x _ { 2 } = g ( x _ { 1 } )$ as a random transformation of the first sample, where $g \in { \mathcal { G } }$ is called a data augmentation (e.g. image rotation). We also generate negative pairs by sampling $x _ { 1 }$ and $x _ { 2 }$ independently.
+
+It is convenient to express these concepts via transformations only. To this end, let $\begin{array} { r l } { D } & { { } = } \end{array}$ $( x _ { 1 } , \dots , x _ { N } ) \in \mathcal { X } ^ { N }$ be a collection of $N$ i.i.d. training data samples. A Generalized Data Transformation (GDT) $T : \mathcal { X } ^ { N } \to \mathcal { Z }$ is a mapping that acts on the set of training samples $D$ to produce a new sample $z = T D$ . Note that the GDT is applied to the entire training set, so that sampling itself can be seen as a transformation. In the simplest case, $\mathcal { Z } = \mathcal { X }$ and a GDT $T = ( i , g )$ extracts the sample corresponding to a certain index $i$ and applies an augmentation $g : \mathcal { X }  \mathcal { X }$ to it, i.e. $T D = g ( x _ { i } )$ .
+
+Usually, we want the function $f$ to be distinctive to the choice of sample but invariant to its augmentation. This is captured by setting the contrast $c ( T , T ^ { \prime } ) ^ { 2 }$ to $c ( ( i , g ) , ( i ^ { \prime } , g ^ { \prime } ) ) = \delta _ { i = i ^ { \prime } }$ . Given a batch $\mathcal { T } = \{ T _ { 1 } , \ldots , \bar { T } _ { K } \}$ of $K$ GDTs, we then optimize a pairwise-weighted version of the noisecontrastive loss (Chen et al., $2 0 2 0 \mathrm { b }$ ; Gutmann $\&$ Hyvärinen, 2010; Oord et al., 2018; Tian et al., 2019; Wu et al., 2018), the GDT-NCE loss:
+
+$$
+\mathcal { L } ( f ; T ) = - \sum _ { T , T ^ { \prime } \in T } c ( T , T ^ { \prime } ) w ( T , T ^ { \prime } ) \log \left( \frac { \exp \left. f ( T D ) , f ( T ^ { \prime } D ) \right. / \rho } { \sum _ { T ^ { \prime \prime } \in T } w ( T , T ^ { \prime \prime } ) \exp \left. f ( T D ) , f ( T ^ { \prime \prime } D ) \right. / \rho } \right) .
+$$
+
+Here, the scalar $\rho$ is a temperature parameter and the weights $w ( T , T ^ { \prime } )$ are set to $\delta _ { T \neq T ^ { \prime } }$ in order to discount contrasting identical transformations, which would result in a weak learning signal. Minimizing eq. (1) pulls together vectors $f ( T D )$ and $f ( T ^ { \prime } D )$ if $c ( T , T ^ { \prime } ) = 1$ and pushes them apart if $c ( T , T ^ { \prime } ) = 0$ , similar to a margin loss, but with a better handling of hard negatives (Chen et al., 2020b; Khosla et al., 2020; Tian et al., 2019).3 When using a single modality, $T = T ^ { \prime }$ and positive pairs are computed from two differently augmented versions.
+
+Multi-modal contrastive formulation. We now further extend GDTs to handle multi-modal data. In this case, several papers (Arandjelovic & Zisserman, 2017; Aytar et al., 2016; Korbar et al., 2018; Owens et al., 2016; Wei et al., 2018) have suggested to learn from the correlation between modalities, albeit usually not in a noise-contrastive manner. In order to encode this with a GDT, we introduce modality projection transformations $m \in \mathcal { M }$ . For example, a video $x = ( v , a )$ has a visual component $v$ and an audio component $a$ and we we have two projections $\mathcal { M } = \{ m _ { a } , m _ { v } \}$ extracting respectively the visual $m _ { v } ( x ) = v$ and audio $m _ { a } ( x ) = a$ signals. We can plug this directly in eq. (1) by considering GDTs $T = ( i , m )$ and setting ${ \dot { T } } { \dot { D } } = m ( x _ { i } )$ , learning a representation $f$ which is distinctive to the choice of input video, but invariant to the choice of modality.4
+
+General case. Existing noise contrastive formulations learn representations that are invariant to an ad-hoc selection of transformations. We show here how to use GDTs to build systematically new valid combinations of transformations while choosing whether to encode invariance or distinctiveness to each factor. Together with the fact that all components, including data sampling and modality projection, are interpreted as transformations, this results in a powerful approach to explore a vast space of possible formulations systematically, especially for the case of video data with its several dimensions.
+
+In order to do so, note that to write the contrastive loss eq. (1), we only require: the contrast $c ( T , T ^ { \prime } )$ , the weight $w ( T , T ^ { \prime } )$ and a way of sampling the transformations $\tau$ in the batch. Assuming that each generalized transformation $T = t _ { M } \circ \cdots \circ t _ { 1 }$ is a sequence of $M$ transformations $t _ { m }$ , we start by defining the contrast $c$ for individual factors as:
+
+$$
+c ( t _ { m } , t _ { m } ^ { \prime } ) = \biggl \{ \begin{array} { l l } { { 1 , } } & { { \mathrm { i f ~ w e ~ h y p o t h e s i z e ~ i n v a r i a n c e , } } } \\ { { \delta _ { t _ { m } = t _ { m } ^ { \prime } } , } } & { { \mathrm { i f ~ w e ~ h y p o t h e s i z e ~ d i s t i n c t i v e n e s s . } } } \end{array} \biggr .
+$$
+
+The overall contrast is then equivalence relation and so $\begin{array} { r } { c ( T , T ^ { \prime } ) = \prod _ { m = 1 } ^ { M } c ( t _ { m } , t _ { m } ^ { \prime } ) } \end{array}$ . In this way, each contrast .1), making it valid in the $c ( t _ { m } , t _ { m } ^ { \prime } )$ is anussed $c ( T , T ^ { \prime } )$   
+above. We also assume that $w ( T , T ^ { \prime } ) = 1$ unless otherwise stated.
+
+Next, we require a way of sampling transformations $\tau$ in the batch. Note that each batch must contain transformations that can be meaningfully contrasted, forming a mix of invariant and distinctive pairs, so they cannot be sampled independently at random. Furthermore, based on the definition above, a single ‘distinctive’ factor in eq. (2) such that $t _ { m } \neq t _ { m } ^ { \prime }$ implies that $c ( T , T ^ { \prime } ) = 0$ . Thus, the batch must contain several transformations that have equal distinctive factors in order to generate a useful learning signal.
+
+A simple way to satisfy these constraints is to use a hierarchical sampling scheme (fig. 1) First, we sample $K _ { 1 }$ instances of transformation $t _ { 1 }$ ; then, for each sample $t _ { 1 }$ , we sample $K _ { 2 }$ instances of transformation $t _ { 2 }$ and so on, obtaining a batch of $\begin{array} { r } { K = \prod _ { m = 1 } ^ { M } K _ { m } } \end{array}$ transformations $T$ . In this manner, the batch contains exactly $K _ { M } \times \cdots \times K _ { m + 1 }$ transformations that share the same first factors $( t _ { 1 } = t _ { 1 } ^ { \prime } , \ldots , t _ { m } = t _ { m } ^ { \prime } )$ . While other schemes are possible, in Appendix A.2.1, we show that this is sufficient to express a large variety of self-supervised learning cues that have been proposed in the literature. In the rest of the manuscript, however, we focus on audio-visual data.
+
+# 3.1 EXPLORING CONTRASTIVE AUDIO-VISUAL SELF-SUPERVISION
+
+Within multi-modal settings, video representation learning on audio-visual data is particularly well suited for exploring the GDT framework. Especially compared to still images, the space of transformations is much larger in videos due to the additional time dimension and modality. It is therefore an ideal domain to explore how GDTs can be used to limit and explore the space of possible transformations and their quality as a learning signal when used as variances or invariances. In order to apply our framework to audio-visual data, we start by specifying how transformations are sampled by using the hierarchical scheme introduced above (see also Figure 1). We consider in particular GDTs of the type $\boldsymbol { T } = ( i , \tau , m , g )$ combining the following transformations. The first component $i$ selects a video in the dataset. We sample $K _ { i } \gg 2$ indices/videos and assume distinctiveness, so that $c ( i , i ^ { \prime } ) = \delta _ { i = i ^ { \prime } }$ . The second component $\tau$ contrasts different temporal shifts. We sample $K _ { \tau } = 2$ different values of a delay $\tau$ uniformly at random, extracting a 1s clip $x _ { i \tau }$ starting at time $\tau$ . For this contrast, we will test the distinctiveness and invariance hypotheses. The third component $m$ contrasts modalities, projecting the video $x _ { i \tau }$ to either its visual or audio component $m ( x _ { i \tau } )$ . We assume invariance $c ( \bar { m } , \bar { m } ^ { \prime } ) \stackrel { - } { = } 1$ and always sample two such transformations $m _ { v }$ and $m _ { a }$ to extract both modalities, so $K _ { m } = 2$ . The fourth and final component $g$ applies a spatial and aural augmentation $T D = g ( m ( x _ { i \tau } ) )$ , also normalizing the data. We assume invariance $c ( g , g ^ { \prime } ) = 1$ and pick $K _ { g } = 1$ . The transformation $g$ comprises a pair of augmentations $( g _ { v } , g _ { a } )$ , where $g _ { v } ( v )$ extracts a fixed-size tensor by resizing to a fixed resolution a random spatial crop of the input video $v$ , and $g _ { a } ( a )$ extracts a spectrogram representation of the audio signal followed by SpecAugment (Park et al., 2019) with frequency and time masking. These choices lead to $K = K _ { i } K _ { \tau } K _ { m } K _ { g } = 4 K _ { i }$ transformations $T$ in the batch $\tau$ .
+
+Testing invariance and distinctiveness hypotheses. The transformations given above combine cues that were partly explored in prior work, contrastive and non-contrastive. For example, Korbar et al. (2018) (not noise-contrastive) learns to detect temporal shifts across modalities. With our formulation, we can test whether distinctiveness or invariance to shifts is preferable, simply by setting $c ( \tau , \tau ^ { \prime } ) = 1$ or $c ( \tau , \tau ^ { \prime } ) = \delta _ { \tau = \tau ^ { \prime } }$ (this is illustrated in fig. 1). We can also set $w ( \tau , \tau ^ { \prime } ) = 0$ for $\tau \neq \tau ^ { \prime }$ to ignore comparisons that involve different temporal shifts. We also test distinctiveness and invariance to time reversal (Wei et al., 2018), which has not previously been explored cross-modally, or contrastively. This is given by a transformation $r \in \bar { \mathcal { R } } = \{ r _ { 0 } , \dot { r } _ { 1 } \}$ , where $r _ { 0 }$ is the identity and $r _ { 1 }$ flips the time dimension of its input tensor. We chose these transformations, time reversal and time shift, because videos, unlike images, have a temporal dimension and we hypothesize that these signals are very discriminative for representation learning.
+
+Ignoring comparisons. Another degree of freedom is the choice of weighting function $w ( T , T ^ { \prime } )$ . Empirically, we found that cross-modal supervision is a much stronger signal than within-modality supervision, so if $T$ and $T ^ { \prime }$ slice the same modality, we set $w ( T , T ^ { \prime } ) = 0$ (see Appendix for ablation).
+
+Understanding combinations. Finally, one may ask what is the effect of combining several different transformations in learning the representation $f$ . A first answer is the rule given in eq. (2) to combine individual contrasts $c ( t _ { m } , t _ { m } ^ { \prime } )$ in a consistent manner. Because of this rule, to a first approximation, $f$ possesses the union of the invariances and distinctivenesses of the individual factors. To obtain a more accurate answer, however, one should also account for the details of the batch sampling scheme and of the choice of weighing function $w$ . This can be done by consulting the diagrams given in fig. 1 by: (1) choosing a pair of transformations $T _ { i }$ and $T _ { j }$ , (2) checking the value in the table (where 1 stands for invariance, 0 for distinctiveness and $\ast$ for ignoring), and (3) looking up the composition of $T _ { i }$ and $T _ { j }$ in the tree to find out the sub-transformations that differ between them as the source of invariance/distinctiveness.
+
+# 4 EXPERIMENTS
+
+We compare self-supervised methods on pretraining audio-visual representations. Quality is assessed based on how well the pretrained representation transfers to other (supervised) downstream tasks. We first study the model in order to determine the best learning transformations and setup. Then, we use the latter to train for longer and compare them to the state of the art.
+
+Self-supervised pretraining. For pretraining, we consider the standard audio-visual pretraining datasets, Kinetics-400 (Kay et al., 2017) and AudioSet (Gemmeke et al., 2017), and additionally, the recently released, VGG-Sound dataset (Chen et al., 2020a). Finally, we also explore how our algorithm scales to even larger, less-curated datasets and train on IG65M (Ghadiyaram et al., 2019) as done in XDC (Alwassel et al., 2020).
+
+Our method learns a pair of representations $\boldsymbol { f } = \left( f _ { v } , f _ { a } \right)$ for visual and audio information respectively and we refer to Appendix A.6 for architectural details.
+
+Downstream tasks. To assess the visual representation $f _ { v }$ , we consider standard action recognition benchmark datasets, UCF-101 (Soomro et al., 2012) and HMDB51 (Kuehne et al., 2011b). We test the performance of our pretrained models on the tasks of finetuning the pretrained representation, conducting few-shot learning and video action retrieval. To assess the audio representation $f _ { a }$ , we train a linear classifier on frozen features for the common ESC-50 (Piczak, 2015) and DCASE2014 (Stowell et al., 2015) benchmarks and finetune for VGG-Sound (Chen et al., 2020a). The full details are given in the Appendix.
+
+Table 1: Learning hypothesis ablation. Results on action classification performance on HMDB-51 is shown for finetuning accuracy (Acc) and frozen action retrieval (recall $@ 5$ ). GDT can leverage signals from both invariance and stronger variance transformation signals, that sole datasample (DS) variance misses.
+
+# 4.1 ANALYSIS OF GENERALIZED TRANSFORMATIONS
+
+<table><tr><td>DS TR TS Mod.</td><td></td><td> Acc r@5</td></tr><tr><td>SimCLR: DS-variance only (a) V · · (b) V i ： （c） V ： i (d) V i i</td><td>V V V V</td><td>47.1 32.5 39.5 31.9 46.9 34.5 46.6 33.4</td></tr><tr><td>(e) V · (f) V （g） V (h) V</td><td>· i ： i i i</td><td>AV AV AV AV GDT: 2-variances</td><td>56.9 49.3 56.1 49.7 57.2 45.2 56.6 44.8</td></tr><tr><td>i V</td><td>V i V vi</td><td>AV AV</td><td>57.5 46.8</td></tr><tr><td>(1)</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>(k)</td><td>V ：V</td><td></td><td>57.0 46.2</td></tr><tr><td></td><td></td><td>AV</td><td></td></tr><tr><td></td><td></td><td></td><td>58.0 50.2</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>V ：</td><td>AV</td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td>58.2 50.2</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>GDT:3-variances</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>(m) v v v AV</td></table>
+
+In this section, we conduct an extensive study on each parameter of the GDT transformation studied here, $T =$ $( i , \tau , m , g )$ , and evaluate the performance by finetuning our network on the UCF-101 and HMDB-51 action recognition benchmarks.
+
+Sample distinctiveness and invariances. First, we experiment with extending SimCLR to video data, as shown in Table 1(a)-(d). This is an important base case as it is the standard approach followed by all recent self-supervised methods (Chen et al., 2020b; He et al., 2019; Wu et al., 2018).
+
+For this, consider GDT of the type $T = ( i , m , \tau , g )$ described above and set $K _ { i } = 7 6 8$ (the largest we can fit in our setup), $K _ { m } = 1$ (only visual modality) and $K _ { g } = 1$ and only pick a single time shift $K _ { \tau } = 1$ . We also set all transformation components to invariance $( c ( t _ { m } , t _ { m } ^ { \prime } ) = 1 ,$ ) except the first that does sample selection. Comparing row (a) to (b-d), we find that adding invariances to time-shift (TS) and time-reversal (TR) consistently degrades the performance compared to the baseline in (a).
+
+GDT variances and invariances Our framework allows fine-grained and expressive control of which invariance and distinctiveness are learned. To demonstrate this flexibility, we first experiment with having a single audio-visual (AV) invariance transformation, in this case data-sampling (DS), i.e. $T = ( i , \tau , m , g )$ . We find immediately an improvement in finetuning and retrieval performance compared to the SimCLR baselines, due to the added audio-visual invariance. Second, we also find that adding invariances to TR and TS does not yield consistent benefits, showing that invariance to these transformations is not a useful signal for learning.
+
+In rows (i-l), we explore the effect of being variant to two transformations, which is unique to our method. We find that: (1) explicitly encoding variance improves representation performance for the TS and TR transformations (58.0 and 58.2 vs 56.9). (2) Ignoring (·) the other transformation as opposed to forcefully being invariant to it works better (58.2 vs 57.0 and 58.0 vs 57.5). Finally, row $\mathrm { ( m ) }$ , shows the (DS, TR, TS)-variance case, yields the best performance when finetuned and improves upon the initial SimCLR baseline by more than $12 \%$ in accuracy and more than $15 \%$ in retrieval $\textcircled { a } 5$ performance. (DS, TR, TS) Compared to row (l), we find that using three variances compared to two does give boost in finetuning performance (58.2 vs 60.0), but there is a slight decrease in retrieval performance (50.2 vs 47.8). We hypothesize that this decrease in retrieval might be due to the 3-variance model becoming more tailored to the pretraining dataset and, while still generalizeable (which the finetuning evaluation tests), its frozen features have a slightly higher domain gap compared to the downstream dataset.
+
+Table 2: Retrieval and Few Shot Learning. Retrieval accuracy in $( \% )$ via nearest neighbors and few shot learning accuracy $( \% )$ via training a linear SVM on fixed representations.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>HMDB UCF120 1 20</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Random                  3.04.52.36.83DRot (Jing&amp; Tian,2018)1  115.0 47.1</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>GDT (ours)              13.4 20.8 26.3 49.4</td></tr><tr><td rowspan=1 colspan=1>eaea</td><td rowspan=1 colspan=1>ClipOrder (Xu et al.,2019) 7.6 48.8 14.1 51.1VCP(Cho et al.,2020)    7.6 53.6 18.6 53.5</td></tr><tr><td rowspan=1 colspan=1>R</td><td rowspan=1 colspan=1>GDT (ours)              25.4 75.0 57.4 88.1</td></tr></table>
+
+Table 3: Audio classification. Downstream task accuracies on standard audio classification benchmarks.   
+
+<table><tr><td>Method Acc% DC ESC</td></tr><tr><td>ConvRBM (Sailor et al., 2017) - 86.5 AVTS (Korbar et al., 2018) 94 82.3 DMC (Hu et al.,2019) 1 82.6 XDC Alwassel et al. (2020) 95</td></tr><tr><td>84.8 AVID (Morgado et al., 2020) 96 89.2</td></tr><tr><td>GDT (ours) 98 88.5 Human (Piczak,2015) 1 81.3</td></tr></table>
+
+Intuition While we only analyse a subset of possible transformations for video data, we nevertheless find consistent signals: While both time-reversal and time-shift could function as a meaningful invariance transformation to provide the model with more difficult positives a-priori, we find that using them instead to force variances consistently works better. One explanation for this might be that there is useful signal in being distinct to these transformations. E.g., for time-reversal, opening a door carries different semantics from from closing one, and for time-shift, the model might profit from being able to differentiate between an athlete running vs an athlete landing in a sandpit, which could be both in the same video. These findings are noteworthy, as they contradict results from the image self-supervised learning domain, where learning pretext-invariance can lead to more transferable representations (Misra & van der Maaten, 2020). This is likely due to the fact that time shift and reversal are useful signals that both require learning strong video representations to pick up on. If instead invariance is learned against these, the “free” information that we have from construction is discarded and performance degrades. Instead, GDT allows one to leverage these strong signals for learning robust representations.
+
+# 4.2 COMPARISON TO THE STATE OF THE ART
+
+Given one of our best learning setups from Sec. 4.1 (row (l)), we train for longer and compare our feature representations to the state of the art in common visual and aural downstream benchmarks.
+
+# Downstream visual benchmarks.
+
+For video retrieval we report recall at 1, 5, 20 retrieved samples for split-1 of the HMDB-51 and UCF-101 datasets in table 2 (the results for recall at 10 and 50 are provided in the Appendix). Using our model trained on Kinetics-400, GDTsignificantly beats all other self-supervised methods by a margin of over $3 5 \%$ for both datasets.
+
+For few-shot classification, as shown in table 2, we significantly beat the RotNet3D baseline on UCF-101 by more than $1 0 \%$ on average for each shot with our Kinetics-400 pretrained model.
+
+For video action recognition, we finetune our GDT pretrained network for UCF-101 and HMDB-51 video classification, and compare against state-of-the-art self-supervised methods in table 4. When constrained to pretraining on the Kinetics datasets, we find that our GDT pretrained model achieves very good results, similar to Morgado et al. (2020) (developed concurrently to our own work). When constrained to pretraining on the AudioSet (Gemmeke et al., 2017) dataset, we also find state-ofthe-art performance among all self-supervised methods, particularly on HMDB-51.
+
+Table 4: State-of-the-art on video action recognition. Self- and fully-supervisedly trained methods on UCF-101 and HMDB-51 benchmarks. We follow the standard protocol and report the average top-1 accuracy over the official splits for finetuning the whole network. Methods with †: use video titles as supervision, with ∗: use ASR generated text. See table A.3 for an extended version including recent/concurrent works.   
+
+<table><tr><td>Method</td><td>Architecture</td><td>Pretraining</td><td>Top-1 Acc% HMDB</td><td>UCF</td></tr><tr><td>Full supervision (Alwassel et al., 2020) Full supervision (ours)</td><td>R(2+1)D-18 R(2+1)D-18</td><td>Kinetics-400 Kinetics-400</td><td>65.1 70.4</td><td>94.2 95.0</td></tr><tr><td>Using Kinetics</td><td></td><td></td><td></td><td></td></tr><tr><td>AoT (Wei et al., 2018) XDC (Alwassel et al., 2020)</td><td>T-CAM R(2+1)D-18</td><td>Kinetics-400 Kinetics-400</td><td>= 52.6</td><td>79.4 86.8</td></tr><tr><td>AV Sync+RotNet (Xiao et al., 2020)</td><td>AVSlowFast</td><td>Kinetics-400</td><td>54.6</td><td>87.0</td></tr><tr><td>AVTS (Korbar et al., 2018)</td><td>MC3-18</td><td>Kinetics-400</td><td>56.9</td><td>85.8</td></tr><tr><td>CPD (Li &amp; Wang,2020)t*</td><td>3D-Resnet50</td><td>Kinetics-400</td><td>57.7</td><td>88.7</td></tr><tr><td>AVID (Morgado et al., 2020)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>60.8</td><td>87.5</td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>60.0</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>89.3</td></tr><tr><td>Using other datasets</td><td></td><td></td><td></td><td></td></tr><tr><td>MIL-NCE (Miech et al., 2020)*</td><td>S3D</td><td>HowTo100M</td><td>61.0</td><td>91.3</td></tr><tr><td>AVTS (Korbar et al., 2018)</td><td>MC3-18</td><td>AudioSet</td><td>61.6</td><td>89.0</td></tr><tr><td>XDC (Alwassel et al., 2020)</td><td>R(2+1)D-18</td><td>AudioSet</td><td>63.7</td><td></td></tr><tr><td></td><td>R(2+1)D-18</td><td></td><td></td><td>93.0</td></tr><tr><td>AVID (Morgado et al.,2020)</td><td></td><td>AudioSet</td><td>64.7</td><td>91.5</td></tr><tr><td>ELo (Piergiovanni et al., 2020)</td><td>R(2+1)D-50x3</td><td>Youtube-2M</td><td>67.4</td><td>93.8</td></tr><tr><td>XDC (Alwassel et al., 2020)</td><td>R(2+1)D-18</td><td>IG65M</td><td>68.9</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>95.5</td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>VGGSound</td><td>61.9</td><td>89.4</td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>AudioSet</td><td>66.1</td><td>92.5</td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>IG65M</td><td>72.8</td><td>95.2</td></tr></table>
+
+We get similar performance to XDC on UCF-101. Lastly, we show the scalability and flexibility of our GDT framework by pretraining on the IG65M dataset (Ghadiyaram et al., 2019). With this, our visual feature representation sets a new state of the art among all self-supervised methods, particularly by a margin of $> 4 \%$ on the HMDB-51 dataset. On UCF-101, we set similar state-of-the-art performance with XDC. Along with XDC, we beat the Kinetics supervised pretraining baseline using the same architecture and finetuning protocol.
+
+For audio classification we find that we achieve state-of-theart performance among all self-supervised methods on both DCASE2014 (DC) and ESC-50 (ESC), and also surpass supervised performance on VGG-Sound with $5 4 . 8 \%$ mAP and $9 7 . 5 \%$ AUC (see Tab. 5).
+
+Table 5: VGG-Sound. Audio classification metrics after full-finetuning.   
+
+<table><tr><td>Method</td><td>mAP AUC d&#x27;</td></tr><tr><td>Supervised 51.69</td><td>96.8 2.63</td></tr><tr><td>GDT (ours) 54.8</td><td>97.5 2.77</td></tr></table>
+
+# 5 CONCLUSION
+
+We introduced the framework of Generalized Data Transformations (GDTs), which allows one to capture, in a single noise-contrastive objective, cues used in several prior contrastive and non-contrastive learning formulations, as well as easily incorporate new ones. The framework shows how new meaningful combinations of transformations can be obtained, encoding valuable invariance and distinctiveness that we want our representations to learn. Following this methodology, we achieved state-of-the-art results for self-supervised pretraining on standard downstream video action recognition benchmarks, even surpassing supervised pretraining. Overall, our method significantly increases the expressiveness of contrastive learning for self-supervision, making it a flexible tool for many multi-modal settings, where a large pool of transformations exist and an optimal combination is sought.
+
+# REFERENCES
+
+Jean-Baptiste Alayrac, Adrià Recasens, Rosalia Schneider, Relja Arandjelovic, Jason Ramapuram, ´ Jeffrey De Fauw, Lucas Smaira, Sander Dieleman, and Andrew Zisserman. Self-supervised multimodal versatile networks. In NeurIPS, 2020.
+
+Humam Alwassel, Bruno Korbar, Dhruv Mahajan, Lorenzo Torresani, Bernard Ghanem, and Du Tran. Self-supervised learning by cross-modal audio-video clustering. In NeurIPS, 2020.
+
+Relja Arandjelovic and Andrew Zisserman. Look, listen and learn. In ICCV, 2017.
+
+Yuki M Asano, Mandela Patrick, Christian Rupprecht, and Andrea Vedaldi. Labelling unlabelled videos from scratch with multi-modal self-supervision. NeurIPS, 2020a.
+
+Yuki M Asano, Christian Rupprecht, and Andrea Vedaldi. Self-labelling via simultaneous clustering and representation learning. In ICLR, 2020b.
+
+Yusuf Aytar, Carl Vondrick, and Antonio Torralba. Soundnet: Learning sound representations from unlabeled video. In NeurIPS, 2016.
+
+Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In NeurIPS, 2019.
+
+Sagie Benaim, Ariel Ephrat, Oran Lang, Inbar Mosseri, William T. Freeman, Michael Rubinstein, Michal Irani, and Tali Dekel. Speednet: Learning the speediness in videos. In CVPR, 2020.
+
+Uta Buchler, Biagio Brattoli, and Bjorn Ommer. Improving spatiotemporal self-supervision by deep reinforcement learning. In ECCV, 2018.
+
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In ECCV, 2018.
+
+Mathilde Caron, Piotr Bojanowski, Julien Mairal, and Armand Joulin. Unsupervised pre-training of image features on non-curated data. In ICCV, 2019.
+
+Honglie Chen, Weidi Xie, Andrea Vedaldi, and Andrew Zisserman. Vggsound: A large-scale audiovisual dataset. In ICASSP, 2020a.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020b.
+
+Hyeon Cho, Taehoon Kim, Hyung Jin Chang, and Wonjun Hwang. Self-supervised spatiotemporal representation learning using variable playback speed prediction. arXiv preprint arXiv:2003.02692, 2020.
+
+Joon Son Chung and Andrew Zisserman. Out of time: automated lip sync in the wild. In Workshop on Multi-view Lip-reading, ACCV, 2016.
+
+Virginia R. de Sa. Learning classification with unlabeled data. In NeurIPS, 1994.
+
+Ali Diba, Vivek Sharma, Luc Van Gool, and Rainer Stiefelhagen. Dynamonet: Dynamic action and motion network. In ICCV, 2019.
+
+Carl Doersch, Abhinav Gupta, and Alexei A Efros. Unsupervised visual representation learning by context prediction. In ICCV, 2015.
+
+Basura Fernando, Hakan Bilen, Efstratios Gavves, and Stephen Gould. Self-supervised video representation learning with odd-one-out networks. In Proc. CVPR, 2017.
+
+Chuang Gan, Boqing Gong, Kun Liu, Hao Su, and Leonidas J Guibas. Geometry guided convolutional neural networks for self-supervised video representation learning. In CVPR, 2019.
+
+Jort F. Gemmeke, Daniel P. W. Ellis, Dylan Freedman, Aren Jansen, Wade Lawrence, R. Channing Moore, Manoj Plakal, and Marvin Ritter. Audio set: An ontology and human-labeled dataset for audio events. In ICASSP, 2017.
+
+Deepti Ghadiyaram, Du Tran, and Dhruv Mahajan. Large-scale weakly-supervised pre-training for video action recognition. In CVPR, 2019.   
+Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. ICLR, 2018.   
+Spyros Gidaris, Andrei Bursuc, Nikos Komodakis, Patrick Pérez, and Matthieu Cord. Learning representations by predicting bags of visual words. In CVPR, 2020.   
+Google. Youtube. https://youtu.be/-Wr6WOXnztk, https://youtu.be/ -BmuSpcrk3U, 2020.   
+Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   
+Michael Gutmann and Aapo Hyvärinen. Noise-contrastive estimation: A new estimation principle for unnormalized statistical models. In AISTATS, 2010.   
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In CVPR, 2006.   
+Tengda Han, Weidi Xie, and Andrew Zisserman. Video representation learning by dense predictive coding. In ICCV Workshops, 2019.   
+Tengda Han, Weidi Xie, and Andrew Zisserman. Self-supervised co-training for video representation learning. In NeurIPS, 2020.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning, 2019.   
+Olivier J Hénaff, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.   
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019.   
+Di Hu, Feiping Nie, and Xuelong Li. Deep multimodal clustering for unsupervised audiovisual learning. In CVPR, 2019.   
+Xu Ji, João F. Henriques, and Andrea Vedaldi. Invariant information clustering for unsupervised image classification and segmentation, 2018.   
+Longlong Jing and Yingli Tian. Self-supervised spatiotemporal feature learning by video geometric transformations. arXiv preprint arXiv:1811.11387, 2018.   
+Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijayanarasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, et al. The kinetics human action video dataset. arXiv preprint arXiv:1705.06950, 2017.   
+Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. Supervised contrastive learning. arXiv preprint arXiv:2004.11362, 2020.   
+Dahun Kim, Donghyeon Cho, and In So Kweon. Self-supervised video representation learning with space-time cubic puzzles. In AAAI, 2019.   
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.   
+Bruno Korbar, Du Tran, and Lorenzo Torresani. Cooperative learning of audio and video models from self-supervised synchronization. In NeurIPS, 2018.   
+H. Kuehne, H. Jhuang, E. Garrote, T. Poggio, and T. Serre. HMDB: a large video database for human motion recognition. In ICCV, 2011a.   
+Hildegard Kuehne, Hueihan Jhuang, Estíbaliz Garrote, Tomaso Poggio, and Thomas Serre. HMDB: a large video database for human motion recognition. In ICCV, 2011b.   
+Hsin-Ying Lee, Jia-Bin Huang, Maneesh Singh, and Ming-Hsuan Yang. Unsupervised representation learning by sorting sequences. In ICCV, 2017.   
+Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. arXiv preprint arXiv:2005.04966, 2020.   
+Tianhao Li and Limin Wang. Learning spatiotemporal features via video and text pair discrimination. arXiv preprint arXiv:2001.05691, 2020.   
+Yang Liu, Samuel Albanie, Arsha Nagrani, and Andrew Zisserman. Use what you have: Video retrieval using representations from collaborative experts. In BMVC, 2019.   
+Dezhao Luo, Chang Liu, Yu Zhou, Dongbao Yang, Can Ma, Qixiang Ye, and Weiping Wang. Video cloze procedure for self-supervised spatio-temporal learning. In AAAI, 2020.   
+Zelun Luo, Boya Peng, De-An Huang, Alexandre Alahi, and Li Fei-Fei. Unsupervised learning of long-term motion dynamics for videos. In CVPR, 2017.   
+Antoine Miech, Jean-Baptiste Alayrac, Lucas Smaira, Ivan Laptev, Josef Sivic, and Andrew Zisserman. End-to-end learning of visual representations from uncurated instructional videos. arXiv.cs, abs/1912.06430, 2019.   
+Antoine Miech, Jean-Baptiste Alayrac, Lucas Smaira, Ivan Laptev, Josef Sivic, and Andrew Zisserman. End-to-end learning of visual representations from uncurated instructional videos. In CVPR, 2020.   
+Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.   
+Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In CVPR, 2020.   
+Ishan Misra, C Lawrence Zitnick, and Martial Hebert. Shuffle and learn: unsupervised learning using temporal order verification. In ECCV, 2016.   
+Pedro Morgado, Nuno Vasconcelos, and Ishan Misra. Audio-visual instance discrimination with cross-modal agreement. arXiv preprint arXiv:2004.12943, 2020.   
+Arsha Nagrani, Chen Sun, David Ross, Rahul Sukthankar, Cordelia Schmid, and Andrew Zisserman. Speech2action: Cross-modal supervision for action recognition. In CVPR, 2020.   
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, 2016.   
+Mehdi Noroozi, Hamed Pirsiavash, and Paolo Favaro. Representation learning by learning to count. In ICCV, 2017.   
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.   
+Andrew Owens and Alexei A Efros. Audio-visual scene analysis with self-supervised multisensory features. In ECCV, 2018.   
+Andrew Owens, Jiajun Wu, Josh H McDermott, William T Freeman, and Antonio Torralba. Ambient sound provides supervision for visual learning. In ECCV, 2016.   
+Daniel S. Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D. Cubuk, and Quoc V. Le. Specaugment: A simple data augmentation method for automatic speech recognition. In INTERSPEECH, 2019.
+
+Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In CVPR, 2016.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014.
+
+Karol J. Piczak. Esc: Dataset for environmental sound classification. In ACM Multimedia, 2015.
+
+AJ Piergiovanni, Anelia Angelova, and Michael S. Ryoo. Evolving losses for unsupervised video representation learning. In CVPR, 2020.
+
+Hardik B. Sailor, Dharmesh M Agrawal, and Hemant A Patil. Unsupervised filterbank learning using convolutional restricted boltzmann machine for environmental sound classification. In INTERSPEECH, 2017.
+
+Nawid Sayed, Biagio Brattoli, and Björn Ommer. Cross and learn: Cross-modal self-supervision. German Conference on Pattern Recognition, 2018.
+
+Kihyuk Sohn. Improved deep metric learning with multi-class n-pair loss objective. In NeurIPS, 2016.
+
+Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. UCF101: A dataset of 101 human action classes from videos in the wild. In CRCV-TR-12-01, 2012.
+
+D. Stowell, D. Giannoulis, E. Benetos, M. Lagrange, and M. D. Plumbley. Detection and classification of acoustic scenes and events. IEEE Transactions on Multimedia, 2015.
+
+Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Contrastive bidirectional transformer for temporal representation learning. arXiv preprint arXiv:1906.05743, 2019a.
+
+Chen Sun, Austin Myers, Carl Vondrick, Kevin Murphy, and Cordelia Schmid. Videobert: A joint model for video and language representation learning. In ICCV, 2019b.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.
+
+Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.
+
+Du Tran, Heng Wang, Lorenzo Torresani, Jamie Ray, Yann LeCun, and Manohar Paluri. A closer look at spatiotemporal convolutions for action recognition. In CVPR, 2018.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.
+
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In NeurIPS, 2016.
+
+Jiangliu Wang, Jianbo Jiao, Linchao Bao, Shengfeng He, Yunhui Liu, and Wei Liu. Self-supervised spatio-temporal representation learning for videos by predicting motion and appearance statistics. In CVPR, 2019.
+
+Donglai Wei, Joseph J Lim, Andrew Zisserman, and William T Freeman. Learning and using the arrow of time. In CVPR, 2018.
+
+Jason Wei and Kai Zou. EDA: Easy data augmentation techniques for boosting performance on text classification tasks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pp. 6382–6388, Hong Kong, China, Nov 2019. Association for Computational Linguistics. doi: 10.18653/v1/D19-1670. URL https://www.aclweb.org/ anthology/D19-1670.
+
+Zhirong Wu, Yuanjun Xiong, Stella X. Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In CVPR, 2018.
+
+Fanyi Xiao, Yong Jae Lee, Kristen Grauman, Jitendra Malik, and Christoph Feichtenhofer. Audiovisual slowfast networks for video recognition. arXiv preprint arXiv:2001.08740, 2020.
+
+Dejing Xu, Jun Xiao, Zhou Zhao, Jian Shao, Di Xie, and Yueting Zhuang. Self-supervised spatiotemporal learning via video clip order prediction. In CVPR, 2019.
+
+Richard Zhang, Phillip Isola, and Alexei A. Efros. Colorful image colorization. In Proc. ECCV, 2016.
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In CVPR, 2017.
+
+Hang Zhao, Chuang Gan, Wei-Chiu Ma, and Antonio Torralba. The sound of motions. In ICCV, 2019.
+
+# A APPENDIX
+
+A.1 THEORY
+
+Full knowledge of the contrast function $c$ only specifies the level sets of the representation $f$ .
+
+Lemma 1. The contrast $c ( x _ { 1 } , x _ { 2 } ) = \delta _ { f ( x _ { 1 } ) = f ( x _ { 2 } ) }$ defines $f = \iota \circ { \hat { f } }$ up to an injection $\iota : \mathcal { X } / f \to \mathcal { Y }$ where $\chi / f$ is the quotient space and ${ \hat { f } } : { \mathcal { X } } \to { \mathcal { X } } / f$ is the projection on the quotient.
+
+Proof. This is a well known fact in elementary algebra. Recall that the quotient $\chi / f$ is just the collection of subsets $X \subset { \mathcal { X } }$ where $f ( x )$ is constant. It is easy to see that this is a partition of $\mathcal { X }$ . Hence, we can define the map ${ \hat { f } } : X \mapsto f ( x )$ where $x$ is any element of $X$ (this is consistent since $f ( x )$ has, by definition, only one value over $X$ ). Furthermore, if $\iota : x \mapsto X = \{ x \in \mathcal { X } : f ( x ^ { \prime } ) =$ $f ( x ) \}$ is the projection of $x$ to its equivalence class $X$ , we have $f ( x ) = { \hat { f } } { \big ( } \iota ( x ) { \big ) }$ . □
+
+Lemma 2. $c ( x _ { 1 } , x _ { 2 } ) = 1$ is an equivalence relation $i f ,$ and only if, there exists a function $f$ such that c(x1, x2) = δf(x1)=f(x2).
+
+Proof. If $c ( x _ { 1 } , x _ { 2 } ) = 1$ defines an equivalence relation on $\mathcal { X }$ , then such a function is given by the projection on the quotient $\hat { f } : \mathcal { X } \to \mathcal { X } / c = \mathcal { y }$ . On the other hand, setting $c ( x _ { 1 } , x _ { 2 } ) =$ $\delta _ { f ( x _ { 1 } ) = f ( x _ { 2 } ) } = 1$ for any given function $f$ is obviously reflexive, symmetric and transitive because the equality $f ( x _ { 1 } ) = f ( x _ { 2 } )$ is. □
+
+The following lemma suggests that defining a contrast $c ( T , T ^ { \prime } )$ on transformations instead of data samples is usually acceptable.
+
+Lemma 3. If $c ( T , T ^ { \prime } ) = 1$ defines an equivalence relation on GDTs, and if $T D = T D ^ { \prime } \Rightarrow T = T ^ { \prime }$ (i.e. different transformations output different samples), then setting $c ( T D , T ^ { \prime } D ) = c ( T , T ^ { \prime } )$ defines part of an admissible sample contrast function.
+
+Proof. If $x = T D$ , $x ^ { \prime } = T ^ { \prime } D$ are obtained from some transformations $T$ and $T ^ { \prime }$ , then these must be unique by assumption. Thus, setting $c ( x , x ^ { \prime } ) = c ( T , T ^ { \prime } )$ is well posed. Reflectivity, symmetry and transitivity are then inherited from the latter. □
+
+Lemma 4. Let $c ( t _ { m } , t _ { m } ^ { \prime } ) = 1$ be reflexive, symmetric and transitive. Their product $c ( T , T ^ { \prime } ) =$ $\begin{array} { r } { \prod _ { m = 1 } ^ { M } c ( t _ { m } , t _ { m } ^ { \prime } ) = h } \end{array}$ as then the same properties.
+
+Proof. The reflexive and symmetric properties are obviously inherited. For the transitive property, note that $c ( T , T ^ { \prime } ) = 1$ if, and only if, $\forall m : c ( t _ { m } , t _ { m } ^ { \prime } ) = 1$ . Then consider:
+
+$$
+\begin{array} { r c l } { c ( T , T ^ { \prime } ) = c ( T ^ { \prime } , T ^ { \prime \prime } ) = 1 } & { \Rightarrow } & { \forall m : c ( t _ { m } , t _ { m } ^ { \prime } ) = c ( t _ { m } ^ { \prime } , t _ { m } ^ { \prime \prime } ) = 1 } \\ & & { \Rightarrow } & { \forall m : c ( t _ { m } , t _ { m } ^ { \prime \prime } ) = 1 \quad \Rightarrow \quad c ( T , T ^ { \prime \prime } ) = 1 . } \end{array}
+$$
+
+# A.2 GENERALITY OF GDT
+
+Here, we show that our GDT formulation can encapsulate and unify other self-supervised works in the literature. We break it down it into two sections:
+
+Mapping contrastive to GDT contrastive Recently, a number of papers have presented contrastive formulations for image representation learning such as, NPID (Wu et al., 2018), PIRL (Misra $\&$ van der Maaten, 2020), MoCo (He et al., 2019) and SimCLR (Chen et al., 2020b). These methods are all essentially built on what we have introduced as the “data-sampling transformation” ${ \mathcal T } = ( i , g )$ , that samples an image with index $i$ and applies augmentation $g$ . For NPID, MoCo and SimCLR, the main objective is to solely be distinctive to the image index, hence $K = K _ { i } K _ { g } = B$ (i.e. the batchsize $B$ ) for NPID, due to the use of a memorybank and $K = K _ { i } K _ { g } = 2 B$ for SimCLR and MoCo. For PIRL, one additional transformation to be invariant to is added. For example, in the case of rotation, the PIRL encodes sample-distinctiveness to the non-rotated inputs
+
+$K = K _ { i } K _ { g } = B$ in the memorybank, while the rotated examples are used for constructing both invariance to the original inputs, as well as sample distinctiveness.
+
+Non-contrastive to GDT contrastive reduction. In non-contrastive self-supervised formulations, one trains $\Phi ( x ) = y$ to regress $y$ from $x$ , where $y$ is some “pretext” task label. These labels can be obtained from the data, e.g. arrow of time (Wei et al., 2018), rotation (Gidaris et al., 2018; Jing & Tian, 2018), shuffled frames (Misra et al., 2016), jigsaw configurations (Kim et al., 2019; Noroozi et al., 2017), or playback speed (Benaim et al., 2020; Cho et al., 2020).
+
+We can reduce these pretext tasks to GDTs in two ways. The first ‘trivial’ reduction amounts to interpreting the supervision $y$ as an additional pseudo-modality. Consider for example RotNet; in this case, the label $y$ should record the amount of rotation applied to the input image. We can achieve this effect by starting from data $z = ( x , 0 )$ where $x$ is an image and 0 a rotation angle. We then sample transformation $t _ { r }$ (rotation) and define its action as $t _ { r } ( \bar { z } ) = ( t _ { r } ( x ) , t _ { r } ( 0 ) )$ where $t _ { r } ( 0 ) = r$ is simply the rotation angle applied and $t _ { r } ( x )$ the rotated image. We consider modality slicing transformations $m _ { x } ( z ) = { \bar { x } }$ and $m _ { r } ( z ) = r$ . To form a batch, we sample GDTs of the type $\bar { \boldsymbol { T } } = ( i , t _ { r } , m )$ , where $i$ is sampled at random, for each i, $t _ { r }$ is exhaustively sampled in a set of four rotations (0, 90, 180, 270 degrees) and, for each rotation $t _ { r }$ , $m$ is also exhaustively sampled, for a total of $K _ { i } K _ { r } K _ { m } = 8 K _ { i }$ transformations in the batch. We define $c ( T , T ^ { \prime } ) \ { \stackrel { . } { = } } \ $ $c ( ( i , t _ { r } , m ) , ( i ^ { \prime } , t _ { r ^ { \prime } } , m ^ { \prime } ) ) = \delta _ { r = r ^ { \prime } }$ (note that we do not learn to distinguish different images; GDTs allow us to express this case naturally as well). We define $w ( T , T ^ { \prime } ) \stackrel { - } { = } \delta _ { i = i ^ { \prime } } \delta _ { m \neq m ^ { \prime } }$ so that images are treated independently in the loss and we always compare a pseudo modality (rotated image) with the other (label). Finally, the network $f _ { r } ( r ) = e _ { r } \in \{ 0 , \bar { 1 } \} ^ { 4 }$ operating on the label pseudo-modality trivially encodes the latter as a 1-hot vector. Then we see that the noise-contrastive loss reduces to
+
+$$
+\sum _ { i } \sum _ { r } \log \frac { \exp \langle f ( t _ { r } ( x _ { i } ) ) , e _ { r } \rangle } { \sum _ { r ^ { \prime } } \exp \langle f ( t _ { r } ( x _ { i } ) ) , e _ { r ^ { \prime } } \rangle }
+$$
+
+which is nearly exactly the same as a softmax loss for predicting the rotation class applied to an image.
+
+There are other reductions as well, which capture the spirit if not the letter of a training signal. For instance, in RotNet, we may ask if two images are rotated by the same amount. This is an interesting example as we do not wish to be distinctive to which image sample is taken, only to which rotation is applied. This can also be captured as a GDT because the sampling process itself is a transformation. In this case, the set of negatives will be the images rotated by a different amount, while the positive example will be an image rotated by the same amount.
+
+Thus, pretext task-originating transformations that have not even been explored yet can be put into our framework and, as we show in this paper, be naturally combined with other transformations leading to even stronger representations.
+
+# A.2.1 POTENTIAL APPLICATION TO TEXT-VIDEO LEARNING
+
+While we focus on audio-visual representation learning due to the multitude of potentially interesting learning signals, it is also possible to apply our framework to other multi-modal settings, such as video-text. Instead of a ResNet-9 as audio encoder, a text-encoder such as wordembeddings (Mikolov et al., 2013; Pennington et al., 2014) with an MLP or a transformer (Vaswani et al., 2017) can be used for encoding the textual inputs and we can train with a cross-modal NCE loss as done currently for audio-visual representation learning in our GDT framework. While the visual transformations can be kept as described in the paper, we can use transformations for text, such as sentence shuffling (Wei & Zou, 2019), or random word swaps (Wei & Zou, 2019). Moreover, unlike prior works in the literature (Alayrac et al., 2020; Li & Wang, 2020; Miech et al., 2019), which mostly focused on model and loss improvements for video-text learning, our framework would allow us to investigate whether it is more desirable to encode either invariance or disctinctiveness to these text transformations for effective video-text representation learning.
+
+# A.3 MODALITY ABLATION
+
+In Table A.1, we provide the results of running our baseline model (sample-distinctiveness only) within-modally instead of across modalities and find a sharp drop in performance.
+
+Table A.1: Multi-modal learning, $m _ { m }$   
+
+<table><tr><td>Modalities Epochs</td><td>HMDB 50100</td><td>UCF 50 ）100</td></tr><tr><td>Within-modal Cross-modal</td><td>29.1 32.9 55.1 56.9</td><td>68.3 72.2 85.1 87.9</td></tr></table>
+
+# A.4 DATASET DETAILS
+
+The Kinetics-400 dataset (Kay et al., 2017) is human action video dataset, consisting of 240k training videos, with each video representing one of 400 action classes. After filtering out videos without audio, we are left with 230k training videos, which we use for pretraining our model.
+
+VGGSound (Chen et al., 2020a) is a recently released audio-visual dataset consisting of 200k short video clips of audio sounds, extracted from videos uploaded to YouTube. We use the training split after filtering out audio (170k) for pretraining our model.
+
+Audioset (Gemmeke et al., 2017) is a large-scale audio-visual dataset of 2.1M videos spanning 632 audio event classes. We use the training split (1.8M) for pretraining our model.
+
+IG65M (Ghadiyaram et al., 2019) is a large-scale weakly supervised dataset collected from a social media website, consisting of 65M videos of human action events. We use the all the videos in the dataset for pretraining.
+
+HMDB-51 (Kuehne et al., 2011a) consists of 7K video clips spanning 51 different human activities.   
+HMDB-51 has three train/test splits of size 5k/2k respectively.
+
+UCF-101 (Soomro et al., 2012) contains 13K videos from 101 human action classes, and has three train/test splits of size 11k/2k respectively.
+
+ESC-50 (Piczak, 2015) is an environmental sound classification dataset which has 2K sound clips of 50 different audio classes. ESC-50 has 5 train/test splits of size $1 . 6 \mathrm { k } / 4 0 0$ respectively.
+
+DCASE2014 (Stowell et al., 2015) is an acoustic scenes and event classification dataset which has 100 training and 100 testing sound clips spanning 10 different audio classes.
+
+# A.5 PREPROCESSING DETAILS
+
+The video inputs are 30 consecutive frames from a randomly chosen starting point in the video. These frames are resized such that the shorter side is between 128 and 160, and a center crop of size 112 is extracted, with no color-jittering applied. A random horizontal flip is then applied with probability 0.5, and then the inputs’ channels are z-normalized using mean and standard deviation statistics calculated across each dataset.
+
+One second of audio is processed as a $1 \times 2 5 7 \times 9 9$ image, by taking the log-mel bank features with 257 filters and 199 time-frames after random volume jittering between $90 \%$ and $110 \%$ is applied to raw waveform, similar to (Arandjelovic & Zisserman, 2017). The spectrogram is then Z-normalized, as in (Korbar et al., 2018). Spec-Augment is then used to apply random frequency masking to the spectrogram with maximal blocking width 3 and sampled 1 times. Similarly, time-masking is applied with maximum width 6 and sampled 1 times.
+
+# A.6 PRETRAINING DETAILS
+
+We use $\mathrm { R } ( 2 + 1 ) \mathrm { D } { - } 1 8 $ (Tran et al., 2018) as the visual encoder $f _ { v }$ and ResNet (He et al., 2016) with 9 layers as the audio encoder $f _ { a }$ unless otherwise noted; both encoders produce a fixed-dimensional output (512-D) after global spatio-temporal average pooling. Both vectors are then passed through two fully-connected layers with intermediate size of 512 to produce 256-D embeddings as in (Bachman et al., 2019) which are normalized by their L2-norm (Wu et al., 2018). The embedding is used for computing the contrastive loss, while for downstream tasks, a linear layer after the global spatiotemporal average pooling is randomly intialized. For NCE contrastive learning, the temperature $\rho$ is set as $1 / 0 . 0 { \dot { 7 } }$ . For optimizing these networks, we use SGD. The SGD weight decay is $1 0 ^ { - 5 }$ and the SGD momentum is 0.9. We use a mini-batch size of 12 on each of our 64 GPUs giving an effective batch size of 768 for distributed training. The initial learning rate is set to 0.01 which we linearly scale with the number of GPUs, after following a gradual warm-up schedule for the first 10 epochs (Goyal et al., 2017). For both Kinetics and VGG-Sound, we train for 200 epochs (3 days), while for Audioset and IG65M, we train for 50 epochs (5 days) and 2 epochs (7 days) respectively.
+
+# A.7 ABLATION EXPERIMENT DETAILS
+
+For the ablations, we only train for 100 epochs on the Kinetics-400 dataset.
+
+For both downstream tasks, we only evaluate on the first fold each but found the performance between folds to be close (within $1 - 2 \%$ ).
+
+# A.8 FULL VIDEO ACTION RETRIEVAL TABLE
+
+In Table A.2 we show the full table on video action retrieval and compare to several of our models, pretrained on different datasets.
+
+Table A.2: Full retrieval table.   
+
+<table><tr><td rowspan="3"></td><td colspan="5">HMDB</td><td colspan="5">UCF</td></tr><tr><td>Recall @ 1</td><td>5</td><td>10</td><td>20</td><td>50</td><td>1</td><td>5</td><td>10</td><td>20</td><td>50</td></tr><tr><td>Supervised (Kinetics)</td><td>49.1</td><td>74.4</td><td>83.9</td><td>90.6</td><td>96.4</td><td>86.9</td><td>94.6</td><td>96.5</td><td>98.1</td><td>99.0</td></tr><tr><td>ST-Puzzle (Kim et al., 2019)</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>19.7</td><td>28.5</td><td>33.5</td><td>40.0</td><td>49.4</td></tr><tr><td>OPN (Lee et al., 2017)</td><td>1</td><td>1</td><td>1</td><td></td><td>1</td><td>19.9</td><td>28.7</td><td>34.0</td><td>40.6</td><td>51.6</td></tr><tr><td>ST Order (Buchler et al.,2018)</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>25.7</td><td>36.2</td><td>42.2</td><td>49.2</td><td>59.5</td></tr><tr><td>ClipOrder (Xu et al.,2019)</td><td>7.6</td><td>22.9</td><td>34.4</td><td>48.8</td><td>68.9</td><td>14.1</td><td>30.3</td><td>40.4</td><td>51.1</td><td>66.5</td></tr><tr><td>SpeedNet (Benaim et al.,2020)</td><td>1</td><td></td><td></td><td></td><td>1</td><td>13.0</td><td>28.1</td><td>37.5</td><td>49.5</td><td>65.0</td></tr><tr><td>VCP (Luo et al., 2020)</td><td>7.6</td><td>24.4</td><td>36.3</td><td>53.6</td><td>76.4</td><td>18.6</td><td>33.6</td><td>42.5</td><td>53.5</td><td>68.1</td></tr><tr><td>VSP (Cho et al., 2020)</td><td>10.3</td><td>26.6</td><td>38.8</td><td>54.6</td><td>76.8</td><td>24.6</td><td>41.9</td><td>51.3</td><td>62.7</td><td>76.9</td></tr><tr><td>GDT (Kinetics)</td><td>25.4</td><td>51.4</td><td>63.9</td><td>75.0</td><td>87.8</td><td>57.4</td><td>73.4</td><td>80.8</td><td>88.1</td><td>92.9</td></tr><tr><td>GDT (VGG-Sound)</td><td>28.4</td><td>55.1</td><td>67.2</td><td>79.3</td><td>91.1</td><td>63.4</td><td>79.6</td><td>85.0</td><td>90.1</td><td>95.2</td></tr><tr><td>GDT (Audioset)</td><td>30.6</td><td>58.0</td><td>69.8</td><td>79.9</td><td>91.0</td><td>65.9</td><td>82.6</td><td>88.2</td><td>92.2</td><td>96.6</td></tr><tr><td>GDT (IG65M)</td><td>36.1</td><td>61.1</td><td>70.8</td><td>79.7</td><td>92.1</td><td>75.7</td><td>87.2</td><td>90.7</td><td>93.5</td><td>96.6</td></tr></table>
+
+# A.9 FULL VIDEO ACTION RECOGNITION TABLE
+
+Table A.3: State-of-the-art on action recognition. Self-supervised and supervised methods on UCF101 and HMDB51 benchmarks. We follow the standard protocol and report the average top-1 accuracy over the official splits and show results for finetuning the whole network. Note that we find the supervised baseline to be around $6 \%$ and $2 \%$ better than reported in (Alwassel et al., 2020) as we use a different finetuning strategy. Methods with $^ { \dagger }$ indicate the additional use of video titles as supervision. Methods with ∗ use ASR generated text. Methods in gray are concurrent works.   
+
+<table><tr><td>Method</td><td>Architecture</td><td>Pretrain Dataset</td><td colspan="2">Top-1 Acc% HMDB UCF</td></tr><tr><td>Full supervision</td><td>R(2+1)D-18</td><td>ImageNet</td><td>46.7</td><td>82.8</td></tr><tr><td>Full supervision (Alwassel et al., 2020)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>65.1</td><td>94.2</td></tr><tr><td>Full supervision (ours)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>70.4</td><td>95.0</td></tr><tr><td>Full supervision (Tran et al., 2018)</td><td>R(2+1)D-34</td><td>Kinetics-400</td><td>74.5</td><td>96.8</td></tr><tr><td>Using UCF</td><td></td><td></td><td></td><td></td></tr><tr><td>Shuffle and Learn (Misra et al., 2016)</td><td>CaffeNet</td><td>UCF</td><td>18.1</td><td>50.2</td></tr><tr><td>VGAN (Vondrick et al., 2016)</td><td>VGAN</td><td>Flickr</td><td></td><td>52.1</td></tr><tr><td>LT-Motion (Luo et al., 2017)</td><td>VGG-16</td><td>UCF</td><td>一</td><td>53.0</td></tr><tr><td>Geometry (Gan et al.,2019)</td><td>CaffeNet</td><td>UCF</td><td>23.3</td><td>55.1</td></tr><tr><td>OPN (Lee et al., 2017)</td><td>VGG</td><td>UCF</td><td>23.8</td><td>56.3</td></tr><tr><td>ST Order (Buchler et al., 2018)</td><td>CaffeNet</td><td>UCF</td><td>25.0</td><td>58.6</td></tr><tr><td>CMC (Tian et al., 2019)</td><td>CaffeNet</td><td>UCF</td><td>26.7</td><td>59.1</td></tr><tr><td>VCP (Luo et al.,2020)</td><td>R(2+1)D-18</td><td>UCF</td><td>32.2</td><td>66.3</td></tr><tr><td>Cross and Learn (Sayed et al., 2018)</td><td>VGG-16</td><td>UCF</td><td>33.0</td><td>70.5</td></tr><tr><td>Using Kinetics</td><td></td><td></td><td></td><td></td></tr><tr><td>ClipOrder (Xu et al., 2019)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>30.9</td><td>72.4</td></tr><tr><td>MotionPred (Wang et al.,2019)</td><td>C3D</td><td>Kinetics-400</td><td>33.4</td><td>61.2</td></tr><tr><td>RotNet3D (Jing&amp; Tian,2018)</td><td>3D-ResNet18</td><td>Kinetics-600</td><td>33.7</td><td>62.9</td></tr><tr><td>ST-Puzzle (Kim et al., 2019)</td><td>3D-ResNet18</td><td>Kinetics-400</td><td>33.7 35.7</td><td>65.8</td></tr><tr><td>DPC (Han et al., 2019)</td><td>3D-ResNet34</td><td>Kinetics-400</td><td>36.8</td><td>75.7 74.8</td></tr><tr><td>VPS (Cho et al., 2020) SpeedNet (Benaim et al., 2020)</td><td>R3D</td><td>Kinetics-400</td><td>43.7</td><td>66.7</td></tr><tr><td>AoT (Wei et al., 2018)</td><td>I3D</td><td>Kinetics-400 Kinetics-400</td><td></td><td>79.4</td></tr><tr><td>CBT (Sun et al.,2019a)</td><td>T-CAM</td><td>Kinetics-600</td><td>、 44.6</td><td>79.5</td></tr><tr><td>Multisensory (Owens &amp; Efros,2018)</td><td>S3D 3D-ResNet18</td><td>Kinetics-400</td><td></td><td>82.1</td></tr><tr><td>XDC (Alwassel et al., 2020)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>52.6</td><td>86.8</td></tr><tr><td>AV Sync+RotNet (Xiao et al., 2020)</td><td></td><td>Kinetics-400</td><td>54.6</td><td>87.0</td></tr><tr><td>AVTS (Korbar et al., 2018)</td><td>AVSlowFast</td><td>Kinetics-400</td><td>56.9</td><td>85.8</td></tr><tr><td>CPD (Li&amp; Wang,2020)†*</td><td>MC3-18</td><td></td><td>57.7</td><td>88.7</td></tr><tr><td></td><td>3D-Resnet50</td><td>Kinetics-400</td><td>60.8</td><td></td></tr><tr><td>AVID (Morgado et al., 2020) CoCLR (Han et al., 2020)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>62.9</td><td>87.5 90.6</td></tr><tr><td></td><td>S3D</td><td>Kinetics-400</td><td></td><td></td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>Kinetics-400</td><td>60.0</td><td>89.3</td></tr><tr><td colspan="5">Using other datasets</td></tr><tr><td>L³-Net (Arandjelovic &amp; Zisserman,2017） VGG-16</td><td></td><td>AudioSet</td><td>40.2</td><td>72.3</td></tr><tr><td>Speech2Action* (Nagrani et al., 2020)</td><td>S3D-G</td><td>MovieDataset</td><td>58.1</td><td></td></tr><tr><td>DynamoNet (Diba et al.,2019)</td><td>ResNext101</td><td>Youtube8M</td><td>58.6</td><td>87.3</td></tr><tr><td>MIL-NCE (Miech et al., 2020)*</td><td>S3D</td><td>HowTo100M</td><td>61.0</td><td>91.3</td></tr><tr><td>AVTS (Korbar et al.,2018)</td><td>MC3-18</td><td>AudioSet</td><td>61.6</td><td>89.0</td></tr><tr><td>XDC (Alwassel et al., 2020)</td><td>R(2+1)D-18</td><td>AudioSet</td><td>63.7</td><td>93.0</td></tr><tr><td>AVID (Morgado et al., 2020)</td><td>R(2+1)D-18</td><td>AudioSet</td><td>64.7</td><td>91.5</td></tr><tr><td>MMV* (Alayrac et al., 2020)</td><td>R(2+1)D-18</td><td>Audioset</td><td>70.1</td><td>91.5</td></tr><tr><td>ELo (Piergiovanni et al., 2020)</td><td>R(2+1)D-50x3</td><td>Youtube-2M</td><td>67.4</td><td>93.8</td></tr><tr><td>XDC(Alwassel et al., 2020)</td><td>R(2+1)D-18</td><td>IG65M</td><td>68.9</td><td>95.5</td></tr><tr><td>MMV* (Alayrac et al., 2020)</td><td>TSM-50x2</td><td>AudioSet+HT100M</td><td>75.0</td><td>95.2</td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>VGGSound (170K)</td><td>61.9</td><td>89.4</td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>AudioSet (1.7M)</td><td>66.1</td><td>92.5</td></tr><tr><td>GDT (ours)</td><td>R(2+1)D-18</td><td>IG65M</td><td>72.8</td><td>95.2</td></tr><tr><td>GDT(ours) (only finetune f c)</td><td>R(2+1)D-18</td><td>IG65M</td><td>55.1</td><td>85.4</td></tr></table>
+
+# A.10 EVALUATION DETAILS
+
+All evaluation code is provided in the Supplementary Material.
+
+Video During training, we take 10 random clips of length 32 frames from each video. For video clip augmentations, we follow a standard protocol as in (Korbar et al., 2018). During evaluation, we uniformly sample 10 clips from each video, average softmax scores, and predict the class having the highest mean softmax score. We then measure the mean video top-1 accuracy across all videos and all official folds. During training, we use SGD with initial learning rate 0.0025, which we gradually warm up to $2 \cdot 1 0 ^ { - 2 }$ in the first 2 epochs. The weight decay is set to $5 \cdot 1 0 ^ { - 3 }$ and momentum to 0.9. We use a mini-batch size of 32 and train for 12 epochs with the learning rate multiplied by $5 \cdot 1 0 ^ { - 2 } ~ $ at 6 and 10 epochs. We compare our GDT pretrained model with both self-supervised methods, and supervised pretraining, and report average top-1 accuracies on UCF101 and HMDB-51 action recognition task across three folds in table A.3.
+
+Few-shot classification We follow the protocol in (Jing & Tian, 2018) and evaluate our our GDT pretrained network using few-shot classification on the UCF-101 dataset, and additionally on HMDB-51. We randomly sample $n$ videos per class from the train set, average the encoder’s global average pooling features from ten clips per training sample and measure classification accuracy performance on the validation set using a $k$ -nearest neighbor classifier, with $k$ set to 1.
+
+Retrieval We follow the standard protocol as outlined in $\mathrm { { X u } }$ et al., 2019). We use the split 1 of UCF101, and additionally HMDB-51. We uniformly sample 10 clips per video, and average the max-pooled features after the last residual block for each clip per video. We use these averaged features from the validation set to query the videos in the training set. The cosine distance of representations between the query clip and all clips in the training set are computed. When the class of a test clip appears in the classes of $k$ nearest training clips, it is considered to be correctly predicted. We report accuracies for $k = 1 , 5 , 1 0 , 2 0 , 5 0$ and compare with other self-supervised methods on UCF101 and HMDB-51 in table A.2.
+
+Audio We extract 10 equally spaced 2-second sub-clips from each full audio sample of ESC50 (Piczak, 2015) and 60 1-second sub-clips from each full sample of DCASE2014 (Stowell et al., 2015). We save the activations that result from the audio encoder to quickly train the linear classifiers. We use activations after the last convolutional layer of the ResNet-9 and apply a max pooling with kernelsize (1,3) and stride of (1,2) without padding to the output. For both datasets, we then optimize a L2 regularized linear layer with batch size 512 using the Adam optimizer (Kingma & Ba, 2015) with learning rate $1 \cdot 1 0 ^ { - 4 }$ , weight-decay set to $5 \cdot 1 0 ^ { - 4 } $ and the default parameters. The classification score for each audio sample is computed by averaging the sub-clip scores in the sample, and then predicting the class with the highest score. The mean top-1 accuracy is then taken across all audio clips and averaged across all official folds. For VGG-Sound (Chen et al., 2020a), we follow their evaluation metrics but follow a much shorter training schedule as our model is pretrained. We optimize the network with batch size 128 using the Adam optimizer (Kingma & Ba, 2015) with learning rate $1 \cdot 1 0 ^ { - 4 }$ for the pretrained backbone and $1 \cdot 1 0 ^ { - 3 }$ for the newly randomly initialized linear layer, weight-decay set to $1 \cdot 1 0 ^ { - 5 }$ and the default parameters. We drop the learning rate at 10 and 20 epochs and train for 30 epochs, which takes less than 10h on a single Nvidia GTX 1080 Titan GPU.

parse/train/r1g1LoAcFm/r1g1LoAcFm.md

@@ -0,0 +1,258 @@
+# USING ONTOLOGIES TO IMPROVE PERFORMANCE IN MASSIVELY MULTI-LABEL PREDICTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Massively multi-label prediction/classification problems arise in environments like health-care or biology where it is useful to make very precise predictions. One challenge with massively multi-label problems is that there is often a longtailed frequency distribution for the labels, resulting in few positive examples for the rare labels. We propose a solution to this problem by modifying the output layer of a neural network to create a Bayesian network of sigmoids which takes advantage of ontology relationships between the labels to help share information between the rare and the more common labels. We apply this method to the two massively multi-label tasks of disease prediction (ICD-9 codes) and protein function prediction (Gene Ontology terms) and obtain significant improvements in per-label AUROC and average precision.
+
+# 1 INTRODUCTION
+
+In this paper, we study general techniques for improving predictive performance in massively multilabel classification/prediction problems in which there is an ontology providing relationships between the labels. Such problems have practical applications in biology, precision health, and computer vision where there is a need for very precise categorization. For example, in health care we have an increasing number of treatments that are only useful for small subsets of the patient population. This forces us to create large and precise labeling schemes when we want to find patients for these personalized treatments.
+
+One large issue with massively multi-label prediction is that there is often a long-tailed frequency distribution for the labels with a large fraction of the labels having very few positive examples in the training data. The corresponding low amount of training data for rare labels makes it difficult to train individual classifiers. Current multi-task learning approaches enable us to somewhat circumvent this bottleneck through sharing information between the rare and cofmmon labels in a manner that enables us to train classifiers even for the data poor rare labels (Caruana, 1997).
+
+In this paper, we introduce a new method for massively multi-label prediction, a Bayesian network of sigmoids, that helps achieve better performance on rare classes by using ontological information to better share information between the rare and common labels. This method is based on similar ideas found in Bayesian networks and hierarchical softmax (Morin & Bengio, 2005). The main distinction between this paper and prior work is that we focus on improving multi-label prediction performance with more complicated directed acyclic graph (DAG) structures between the labels while previous hierarchical softmax work focuses on improving runtime performance on multi-class problems (where labels are mutually exclusive) with simpler tree structures between the labels.
+
+In order to demonstrate the empirical predictive performance of our method, we test it on two very different massively multi-label tasks. The first is a disease prediction task where we predict ICD-9 (diagnoses) codes from medical record data using the ICD-9 hierarchy to tie the labels together. The second task is a protein function prediction task where we predict Gene Ontology terms (Ashburner et al., 2000; Carbon et al., 2017) from sequence information using the Gene Ontology DAG to combine the labels. Our experiments indicate that our new method obtains better average predictive performance on rare labels while maintaining similar performance on common labels.
+
+# 2 METHODS
+
+# 2.1 PROBLEM SETUP
+
+The goal of multi-label prediction is to learn the distribution $P ( L | X )$ which gives the probability of an instance $X$ having a label $L$ from a dictionary of $N$ labels. We are particularly interested in the case where there is an ontology providing superclass relationships between the labels. This ontology consists of a DAG where every label $L$ is a node and every directed edge from $L _ { i }$ to $L _ { j }$ indicates that the label $L _ { i }$ is a superclass of the label $L _ { j }$ . Figure 1 gives corresponding example simplified subgraphs from both the ICD-9 hierarchy and the Gene Ontology DAG. We define parents ${ \bf \nabla } \cdot ( L )$ to be the direct parents of $L$ . We define ancestor $s ( L )$ to be all of the nodes that have a directed path to $L$ .
+
+![](images/93446a772d4b23aee07a1ac3b0b24cc501ecef1c47e60ba99e246db593e63a31.jpg)  
+Figure 1: Example simplified graphs showing superclass relationships from the ICD-9 hierarchy and the Gene Ontology DAG.
+
+The classical approach for solving this problem is to learn separate functions for each label. This transforms the problem into $N$ binary prediction problems which can each be solved with standard techniques. The main issue with this approach is that it is less sample efficient in that it does not share information between the labels. A more sophisticated approach is to use multi-task learning techniques to share information between the individual label-specific binary classifiers. One approach for doing this with neural networks is to introduce shared layers between the different binary classifiers. The resulting output layer is a flat structure of sigmoid outputs, with each sigmoid output representing one $P ( L | X )$ . This reduces the number of parameters needed for every label and allows information to be shared among the labels (Caruana, 1997). However, even with this weight sharing, the final output layer still needs to be learned independently for each label.
+
+# 2.2 BAYESIAN NETWORK FACTORIZATION
+
+We propose a modification of the output layer by constructing a Bayesian network of sigmoids in order to use the ontology to share additional information between labels in a more guided way. The general idea is that we assume that the probability of our labels follows a Bayesian network (Pearl, 1988) with each edge in the ontology representing an edge within the Bayesian network. This, along with the fact that the edges denote superclasses, enables us to factor the probability of a label into several conditional probabilities.
+
+$$
+\begin{array} { l } { { P ( L | X ) = P ( L , a n c e s t o r s ( L ) | X ) } } \\ { { \ } } \\ { { \displaystyle = \prod _ { \ell \in \{ L \} \cup a n c e s t o r s ( L ) } P ( \ell | X , p a r e n t s ( \ell ) ) } } \end{array}
+$$
+
+As the edges denote superclasses, having a child label implies having every ancestor
+
+From Baysian network assumption on the subgraph consisting of $L$ and ancestor ${ \bf \nabla } ^ { \mathrm { * } } ( L )$ (Pearl, 1988)
+
+We are now able to learn the conditional probability distributions $P ( L | X , p a r e n t s ( L ) )$ for every label in the ontology and use the above formula to reconstruct the final target probabilities
+
+$P ( L | X )$ . Consider the example simplified ICD-9 graph in Figure 1. For this graph, we would learn $P ( C a n c e r | X ) , P ( L u n g C a n c e r | C a n c e r , X )$ , and $P ( S k i n C a n c e r | C a n c e r , X )$ . We would then be able to compute $P ( L u n g C a n c e r | X ) = P ( C a n c e r | X ) \times P ( L u n g C a n c e r | C a n c e r , X ) .$
+
+The intuition of why this factoring might be useful is that it enables the transferring of knowledge from more common higher-level labels to more rare lower-level labels. Consider the case where $L$ is very rare. In that case it is difficult to learn $P ( L | X )$ directly due to the small amount of training data. However, the decomposed version $\begin{array} { r } { \prod _ { \ell \in \{ L \} \cup a n c e s t o r s ( L ) } P ( \ell | X , p a r e n t s ( \ell ) ) } \end{array}$ includes classifiers from the ancestors of $L$ that have more training data and might be easier to learn. This factoring allows additional signal from the better trained higher-level labels to feed directly into the probability computation for the rare leaf $L$ . If we can rule out one of the higher-level labels, we can also rule out a lower-level label. For example, consider the ICD-9 graph illustrated in Figure 1. We might not have enough patients with lung cancer to directly learn an optimal $P ( L u n g C a n c e r | X )$ . However, we can pool all of our cancer patients to learn a hopefully more optimal $P ( C a n c e r | X )$ . We can then use our Bayesian network factoring to incorporate the better trained $P ( C a n c e r | X )$ classifier in our calculation for $P ( L u n g C a n c e r | X )$ . In our experiments we show that this intuition plays out in practice through improved performance on rare labels.
+
+The Bayesian network assumption plays an important role in allowing us to factor the probabilities in this manner. In order to perform our factoring, we must assume that every subgraph of the ontology consisting of the nodes $\{ L \} \cup a n c e s t o r s ( L )$ correctly represents a Bayesian network for the label probability distribution. These subgraphs are only correct Bayesian networks if the probability of every label $L$ is conditionally independent of the probabilities of non-descendent labels given the parent labels and $X$ (Russell & Norvig, 2009). This might seem somewhat limiting, but there are two reasons why this assumption is weaker than it might appear. First, we only require a Bayesian network to be correct for the subgraphs of the form $\{ L \} \cup a n c e s t o r s ( L )$ . This is true because we only consider the nodes $\{ L \} \cup a n c e s t o r s ( L )$ when we do our factoring. This is a significantly weaker assumption than requiring the entire graph to follow a Bayesian network. One direct application of this is that every tree ontology can meet this assumption. The proof for this is that every $\{ L \} \cup a n c e s t o r s ( L )$ subgraph of a tree is a simple chain. A simple chain is not able to violate the conditional independence assumption behind Bayesian networks because it has no non-descendent nodes that are not already ancestors. Ancestor nodes are always conditionally independent with the label given the parents because the edges represent superclasses and thus either the ancestors are always present if the parent i present or the label is always not present if the parent is not present. The second reason why this assumption is weaker than it might appear is that we only require conditional independence given a particular instance $X$ . As an illustrative example, consider the two ICD-9 labels of male breast cancer (ICD-9 175) and female breast cancer (ICD-9 174). Male breast cancer and female breast cancer are trivially not conditionally independent due to the gender qualifier making them mutually exclusive. However, male breast cancer and female breast cancer become conditionally independent once you condition on the gender of the patient. Thus conditioning on the exact instance $X$ enables more conditional independence than would otherwise be available. Nevertheless, even with these caveats, there will be some circumstances in which this conditional independence assumption is violated. In these situations, our factoring is not valid and our computed product $\Pi _ { \ell \in \{ L \} \cup a n c e s t o r s ( L ) } P ( \ell | X , p a r e n t s ( \ell ) )$ might diverge from the actual $P ( L | X )$ . Yet, even in these situations, the resulting scores can still be empirically useful. We demonstrate that this is the case in our experiments by showing performance improvements in a protein function prediction task that almost assuredly violates this conditional independence assumption.
+
+# 2.3 MODELING THE PROBABILITIES WITH SIGMOID
+
+There are many potential ways in which the conditional probabilities $P ( L | X , p a r e n t s ( L ) )$ could be modeled. We exclusively focus on modeling these probabilities using a sigmoid function computed on logits from neural networks. We define an encoder neural network for every task that takes in the input $X$ and returns a fixed-length representation of the input. We also define a fixed-length embedding for every label $L$ by constructing an output embedding matrix such that $e _ { L }$ is the embedding for $L$ . This encoder and label embedding then allow us to model $P ( L | X , p a r e n t s ( L ) )$ as $\sigma ( e n c o d e r ( X ) \cdot e _ { L } )$ , where $\sigma$ indicates the sigmoid function and $\ast$ indicates a dot product. Note that $p a r e n t s ( L )$ is not used in this formula. This is because there is a unique set of parents for every label $L$ , so there is no need to have distinct $e _ { L }$ vectors for different sets of parents. We can then train
+
+$P ( L | X , p a r e n t s ( L ) )$ by using cross entropy loss on patients who have all the labels in parent ${ \mathfrak { s } } ( L )$ . Note that we explicitly do not train each of the conditional probabilities on every patient. We can only train the conditional probabilities on patients who satisfy the conditional requirement of having the parent labels. This does not change the number of positive examples for each classifier, but it does significantly reduce the number of negative examples for the lower level classifiers.
+
+For example, consider the ICD-9 subgraph shown in Figure 1. In this situation, we have three labels and thus need to learn three conditional probabilities: $\bar { P ( } C a n c e r | X ) , P ( L u n g C a n c e r | C a n c e r , X )$ and $P ( B r e a s t C a n c e r | C a n c e r , X )$ . We have three labels, so our label embedding matrix consists of $e _ { C a n c e r }$ , eLungCancer and eBreastCancer. We can now compute $P ( L u n g C a n c e r | X )$ and $P ( B r e a s t C a n c e r | X )$ as follows:
+
+$$
+\begin{array} { r } { P ( L u n g C a n c e r | X ) = P ( L u n g C a n c e r | C a n c e r , X ) \times P ( C a n c e r | X ) \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } \\ { = \sigma ( e n c o d e r ( X ) \cdot e _ { L u n g C a n c e r } ) \times \sigma ( e n c o d e r ( x ) \cdot e _ { C a n c e r } ) \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { P ( B r e a s t C a n c e r | X ) = P ( B r e a s t C a n c e r | C a n c e r , X ) \times P ( C a n c e r | X ) } \\ & { \quad \quad = \sigma ( e n c o d e r ( X ) \cdot e _ { B r e a s t C a n c e r } ) \times \sigma ( e n c o d e r ( X ) \cdot e _ { C a n c e r } ) } \end{array}
+$$
+
+As a baseline, we also train models with a normal flat sigmoid output layer. In these models we directly learn $P ( L | X )$ for each label. Similar to the conditional probabilities, we can define these probabilities as a sigmoid of the output from a neural network. We define $P ( L | X )$ to be $\sigma ( e n c o d e r ( X ) \cdot e _ { L } )$ . We can then train $P ( L | X )$ using cross entropy loss on all patients.
+
+# 3 EXPERIMENTAL SETUP
+
+We evaluated the predictive performance of our method on two very different massively multi-label problems. We consider the task of predicting future diseases for patients given medical history in the form of ICD-9 codes and the task of predicting protein function from sequence data in the form of Gene Ontology terms. In this section, we introduce the datasets, encoders and baselines used for each problem.
+
+# 3.1 DISEASE PREDICTION
+
+# 3.1.1 PROBLEM
+
+One of our experiments consists of predicting diseases in the form of ICD-9 codes from electronic medical record (EMR) data. We have two years and nine months of data covering 2013, 2014, and the first nine months of 2015. We use two years of history to predict which ICD-9 codes will appear in the following nine months. The problem setup for this experiment closely matches the setup in Miotto et al. (2016). We use a large insurance claims dataset from [redacted to preserve anonymity] for modeling. Our claims data consists of diagnoses (ICD-9), medications (NDC), procedures (CPT), and some metadata such as age, gender, location, general occupation, and employment status. We restrict our analysis to patients who were enrolled during 2013, 2014 and January 2015.
+
+We have 15.7 million patients, of which a random $5 \%$ are used for validation and $5 \%$ are used for testing. This dataset is quite large, much larger than what is usually available in a hospital. Thus we consider two cases of this problem. The “high data case” is where we use all remaining 14.1 million patients for training. The “ low data case” consists of training with a $2 \%$ random sample of 281,874 patients and is much closer in size to normal hospital datasets (Choi et al., 2017; Avati et al., 2017).
+
+Our target label dictionary for this task consists of all leaf ICD-9 billing codes that appear at least 5 times in the training data. We only predict leaf codes as those are the only codes allowed for billing and thus the only ICD-9 codes that records are annotated with. This results in a dictionary of 6,902 codes for the small disease prediction task and 12,533 codes for the large disease prediction task. We use the ICD-9 hierarchy included in the 2018AA UMLS release (Bodenreider, 2004) in order to construct relationships between the labels for our method. We additionally use the CPT and ATC ontologies included in the 2018AA for our encoder.
+
+![](images/de4256377e4fd9a15604d571ab33bf83b7c5ffe62895b56258821e735f97412c.jpg)  
+Figure 2: The partitioning of the patient timelines into input history and output prediction labels as well as the subpartioning of the input history into time-bins. Each tick on the $\mathbf { X }$ -axis represents one month. The first two years of information is used as input and the final nine months is used to generate output prediction labels. These first two years are subdivided into six bins of the following lengths for featurization: one year, six months, three months, one month, one month, and one month.
+
+# 3.1.2 ENCODER DESCRIPTION
+
+For our encoder, we use a feed-forward architecture inspired by Avati et al. (2017). As in their model, we split our two years of data into time-sliced bins. For each time slice, we find all the ICD-9, NDC and CPT codes that the patient experienced during the time slice. Figure 2 details the exact layout of each time bin. We also add a feature for every higher-level code in the ICD-9, ATC and CPT ontologies that indicates whether the patient had any of the descendants of that particular code within the time slice. This expanded rollup scheme is structurally very similar to the subword method introduced in Bojanowski et al. (2017). The weights for these input embeddings are tied to the output embedding matrix used in our output layers. We summarize the set of embeddings for each time bin using mean pooling. We also construct mean embedding for the metadata by feeding the metadata entries through an embedding matrix followed by mean pooling. Finally, we concatenate the means from each timeslice with the mean embeddings from the metadata and feed the resulting vector into a feedforward neural network to compute a final patient embedding.
+
+These neural network models are trained with the Adam optimizer. The hyperparameters such as the learning rate, layer size, non-linearity, and number of layers are optimized using a grid search on the validation set. Appendix A.1 has details on the space searched as well as the best hyper-parameters for both the normal sigmoid and Bayesian network sigmoid models.
+
+Finally, as a further baseline, we also train logistic regression models individually for several rare ICD-9 codes. These models are trained on a binary matrix where each row represents a patient and each column represents an ICD-9 code, NDC code, CPT code, or metadata element. A particular row and column element is set to 1 whenever a patient has that particular item in the metadata or during the two years of provided medical history. These logistic regression models are regularized with L2 with a lambda optimized using cross-validation. One particular issue with training individual models on rare codes is that the dataset is distinctly unbalanced with vastly more negative examples than positive examples. We deal with this issue by subsampling negative examples so that the ratio of positive and negative samples is 1:10.
+
+# 3.2 PROTEIN FUNCTION PREDICTION
+
+# 3.2.1 PROBLEM
+
+For our other experiment, we predict protein functions in the form of Gene Ontology (GO) terms from sequence data. We focus only on human proteins that have at least one Gene Ontology annotation. Our features consist of amino acid sequences downloaded from Uniprot on July 27, 2018 (Consortium, 2017). For our labels, we use the human GO labels which were generated on June 18, 2018. After joining the labels with the sequence data, we have a total of 15,497 annotated human protein sequences. A random $80 \%$ of the sequences are used for training, $10 \%$ are using for validation, and a final $10 \%$ are used for final testing.
+
+In this task we predict all leaf and higher level GO terms that appear at least 5 times in the training data. This results in a target dictionary of 7,751 terms. We construct relationships between these labels using the July 24, 2018 release of the GO basic ontology.
+
+# 3.2.2 ENCODER DESCRIPTION
+
+We use Kim (2014)’s 1-D CNN based encoder to encode our protein sequence information. We treat every letter in the alphabet as a word and encode each of those letters with an embedding size of size 26. We then apply a 1-D convolution with a window size of 8 over the embedded sequence. A fixed-length representation of the protein is then obtained by doing max-over-time pooling. This representation is finally fed through a ReLU and one fully connected layer. The resulting fixed dimension vector is the encoded protein. For regularization, we add dropout before the convolution and fully connected layer.
+
+Following previous work, we also consider generating features using sequence alignment (Kulmanov et al., 2018). We use version 2.7.1 of the BLAST tool to find the most similar training set protein for every protein in our dataset (Wheeler et al., 2007). We then use this most similar protein to augment our protein encoder by adding a binary feature which signifies if the most similar protein has the particular term we are predicting.
+
+These CNN models are trained with Adam. Hyperparameters such as learning rate, number of filters, dropout, and the size of the final layer are optimized using a grid search on the validation set. See Appendix A.1 for a full listing of the space searched as well as the best hyperparameters for both the flat sigmoid and Bayesian network of sigmoids models.
+
+As a further baseline, we also consider using the BLAST features alone for predicting protein function. This model simply consists of a 1 if the most similar protein has the target term or a 0 otherwise.
+
+For these protein models, we also consider one final baseline where we take our flat sigmoid model and weight labels according to the inverse square root of their frequency. This weighting scheme is based off the subsampling scheme from Mikolov et al. (2013). Unfortunately, this baseline did not seem to perform well on rare words so we did not consider it for the disease case and our more general analysis. The results for this baseline can be found in Appendix A.3.
+
+# 4 RESULTS
+
+Figure 3 shows frequency binned per-label area under the receiver operating characteristic (AUROC) and average precision (AP) for less frequent labels that have at most 1,000 positive examples. See Appendix A.2 for the exact numerical results which include $95 \%$ bootstrap confidence intervals generated through 500 bootstrap samples of the test set. As shown in Figure 4, these less frequent labels cover a majority of the labels within each dataset. Our results indicate that the Bayesian network of sigmoid output layer has better AUROC and average precision for rare labels in all three tasks, with the effect diminishing with increasing numbers of positive labels. This effect is especially strong in the average precision space. For example, the Bayesian network of sigmoid models obtain $187 \%$ , $2 8 . 5 \%$ and $1 7 . 9 \%$ improvements in average precision for the rarest code bin (5-10 positive examples) over the baseline models for the small disease, large disease and protein function tasks, respectively. This improvement persists for the next rarest bin (11-25 positive examples), but decreases to $8 9 . 2 \%$ , $1 0 . 7 \%$ and $1 1 . 1 \%$ . This matches our previous intuition as there is no need to transfer information from more general labels if there is enough data to model $P ( L | X )$ directly.
+
+Table 1 compares micro-AUROC and micro-AP on all labels for all three tasks. The benefits of the Bayesian sigmoid output layer seem much more limited and task specific in this setting. We do not expect significantly better results in the micro averaged performance case because the micro results are more dominated by more frequent codes and the Bayesian network of sigmoids is only expected to help when $P ( L | X )$ does not have enough data to be modeled directly. The Bayesian network of sigmoids output layer provides better AUROC and AP for the disease prediction task, but suffers from worse performance in the protein function task. One possible explanation for this discrepancy is that our Bayesian network assumption is guaranteed to be correct in the disease prediction task due to the tree structure of the ontology, but might not be correct in the protein function task with its more complicated DAG ontological structue. It is possible that minor violations of the Bayesian network assumption in the protein function prediction task cause the overall performance to be worse on the more common code compared to the flat sigmoid decoder.
+
+![](images/95b0e5bef9f12fbfba98427c6bcafe0246ab83a571bbf99d8877253d79051d82.jpg)  
+Figure 3: Frequency binned per-label AUROC and average precision (AP) for less frequent labels with at most 1,000 positive examples. AUROC and AP are calculated independently for each individual label. Labels are then grouped into bins determined by the number of positive samples per label and average statistics are computed for each bin. The $\mathbf { X }$ -axis is in log-scale and represents the number of possible examples for the center of each bin. Each line represents the type of model, with the baseline model differing between the disease prediction and protein function prediction tasks.
+
+![](images/8f00e571eb316dacfa60c9c169ba200c961b91d1a88abf101247c3d6814a0443.jpg)  
+Figure 4: The cumulative frequency distribution for the target labels in the various tasks. The x-axis is in log scale.
+
+# 5 RELATED WORK
+
+There is related work on improved softmax variants, predicting ICD-9 codes, predicting Gene Ontology terms and combining ontologies with Bayesian networks.
+
+Table 1: Micro-AUROC and micro-average precision (AP) results on the various tasks.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Small Disease</td><td colspan="2">Large Disease</td><td colspan="2">Protein Function</td></tr><tr><td>AUROC</td><td>AP</td><td>AUROC</td><td>AP</td><td>AUROC</td><td>AP</td></tr><tr><td>Flat Sigmoid</td><td>0.951</td><td>0.209</td><td>0.982</td><td>0.262</td><td>0.945</td><td>0.436</td></tr><tr><td>Bayesian Network of Sigmoids</td><td>0.960</td><td>0.220</td><td>0.982</td><td>0.269</td><td>0.935</td><td>0.430</td></tr></table>
+
+Improved softmax variants. There has been a wide variety of work focusing on trying to come up with improved softmax variants for use in massively multi-class problems such as language modeling. This prior work primarily differs from this work in that it focuses exclusively on the multi-class case with a tree structure connecting the labels. Multi-class is distinct from multi-label in that multi-class requires each item to only have one label while multi-label allows multiple labels per item. Most of this work focuses around trying to improve the training time for the expensive softmax operation found in multi-class problems such as large-vocabulary language modeling. The most related of these variants fall under the hierarchical softmax family. Hierarchical softmax from Morin & Bengio (2005) (and related versions such as class based softmax from Goodman (2001) and adaptive softmax from Grave et al. (2016)) focuses on speeding up softmax by using a tree structure to decompose the probability distribution.
+
+Disease prediction. Previous work has also explored the task of disease prediction through predicting ICD-9 codes from medical record data (Miotto et al., 2016; Choi et al., 2017; 2015). GRAM from Choi et al. (2017) is a particularly relevant instance which uses the CCS hierarchy to improve the encoder, resulting in better predictions for rare codes. Our work differs from GRAM in that we improve the output layer while GRAM improves the encoder.
+
+Protein function prediction. Protein function prediction in the form of Gene Ontology term prediction has been considered by previous work (Kulmanov et al., 2018; Lan et al., 2013; Cao et al., 2017). DeepGO from Kulmanov et al. (2018) is the most similar to the approach taken by this paper in that it uses a CNN on the sequence data to predict Gene Ontology terms. It also uses the ontology in that it creates a multi-task neural network in the shape of the ontology. Our work differs from DeepGO in that we focus on the rarer terms and we only modify the output layer.
+
+Combining ontologies with Bayesian networks. Phrank from Jagadeesh et al. (2018) is an algorithm for computing similarity scores between sets of phenotypes for use in diagnosing genetic disorders. Like this paper, Phrank constructs a Bayesian network based on an ontology. This work differs from Phrank in that we focus on the supervised prediction task of modeling the probability of a label given an instance while Phrank focuses on the simpler task of modeling the unconditional probability of a label (or set of labels).
+
+# 6 CONCLUSION
+
+This paper introduces a new method for improving the performance of rare labels in massively multi-label problems with ontologically structured labels. Our new method uses the ontological relationships to construct a Bayesian network of sigmoid outputs which enables us to express the probability of rare labels as a product of conditional probabilities of more common higher-level labels. This enables us to share information between the labels and achieve empirically better performance in both AUROC and average precision for rare labels than flat sigmoid baselines in three separate experiments covering the two very different domains of protein function prediction and disease prediction. This improvement in performance for rare labels enables us to make more precise predictions for smaller label categories and should be applicable to a variety of tasks that contain an ontology that defines relationships between labels.
+
+# ACKNOWLEDGMENTS
+
+This section has been redacted to preserve anonymity.
+
+# REFERENCES
+
+M Ashburner, C A Ball, J A Blake, D Botstein, H Butler, J M Cherry, A P Davis, K Dolinski, S S Dwight, J T Eppig, M A Harris, D P Hill, L Issel-Tarver, A Kasarskis, S Lewis, J C Matese, J E Richardson, M Ringwald, G M Rubin, and G Sherlock. Gene ontology: tool for the unification of biology. the gene ontology consortium. Nat Genet, 25(1):25–29, May 2000. doi: 10.1038/75556. URL http://www.ncbi.nlm.nih.gov/pubmed/10802651.
+
+A. Avati, K. Jung, S. Harman, L. Downing, A. Ng, and N. H. Shah. Improving palliative care with deep learning. In 2017 IEEE International Conference on Bioinformatics and Biomedicine (BIBM), pp. 311–316, Nov 2017. doi: 10.1109/BIBM.2017.8217669.
+
+Olivier Bodenreider. The unified medical language system (umls): integrating biomedical terminology. Nucleic Acids Research, 32:D267–D270, 2004. doi: 10.1093/nar/gkh061. URL http://dx.doi.org/10.1093/nar/gkh061.
+
+Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. Enriching word vectors with subword information. Transactions of the Association for Computational Linguistics, 5:135–146, 2017. URL http://aclweb.org/anthology/Q17-1010.
+
+Renzhi Cao, Colton Freitas, Leong Chan, Miao Sun, Haiqing Jiang, and Zhangxin Chen. Prolango: Protein function prediction using neural machine translation based on a recurrent neural network. Molecules, 22(10), 2017. ISSN 1420-3049. doi: 10.3390/molecules22101732. URL http: //www.mdpi.com/1420-3049/22/10/1732.
+
+S. Carbon, H. Dietze, S. E. Lewis, C. J. Mungall, M. C. Munoz-Torres, S. Basu, R. L. Chisholm, R. J. Dodson, P. Fey, Paul D. Thomas, H. Mi, A. Muruganujan, X. Huang, S. Poudel, J. C. Hu, S. A. Aleksander, B. K. McIntosh, D. P. Renfro, D. A. Siegele, G. Antonazzo, H. Attrill, N. H. Brown, S. J. Marygold, P. Mc-Quilton, L. Ponting, G. H. Millburn, A. J. Rey, R. Stefancsik, S. Tweedie, K. Falls, A. J. Schroeder, M. Courtot, D. Osumi-Sutherland, H. Parkinson, P. Roncaglia, R. C. Lovering, R. E. Foulger, R. P. Huntley, P. Denny, N. H. Campbell, B. Kramarz, S. Patel, J. L. Buxton, Z. Umrao, A. T. Deng, H. Alrohaif, K. Mitchell, F. Ratnaraj, W. Omer, M. Rodr´ıguezLopez, and The Gene Ontology Consortium. Expansion of the gene ontology knowledgebase and ´ resources: The gene ontology consortium. Nucleic Acids Research, 45(D1):D331–D338, 1 2017. ISSN 0305-1048. doi: 10.1093/nar/gkw1108.
+
+Rich Caruana. Multitask learning. Machine learning, 28(1):41–75, 1997.
+
+Edward Choi, Mohammad Taha Bahadori, and Jimeng Sun. Doctor AI: predicting clinical events via recurrent neural networks. CoRR, abs/1511.05942, 2015. URL http://arxiv.org/abs/ 1511.05942.
+
+Edward Choi, Mohammad Taha Bahadori, Le Song, Walter F. Stewart, and Jimeng Sun. Gram: Graph-based attention model for healthcare representation learning. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’17, pp. 787–795, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4887-4. doi: 10.1145/ 3097983.3098126. URL http://doi.acm.org/10.1145/3097983.3098126.
+
+The UniProt Consortium. Uniprot: the universal protein knowledgebase. Nucleic Acids Research, 45(D1):D158–D169, 2017. doi: 10.1093/nar/gkw1099. URL http://dx.doi.org/10. 1093/nar/gkw1099.
+
+Joshua Goodman. Classes for fast maximum entropy training. In Acoustics, Speech, and Signal Processing, 1988. ICASSP-88., 1988 International Conference on, volume 1, pp. 561 – 564 vol.1, 02 2001. ISBN 0-7803-7041-4.
+
+Edouard Grave, Armand Joulin, Moustapha Cisse, David Grangier, and Herv ´ e J ´ egou. Efficient ´ softmax approximation for gpus. CoRR, abs/1609.04309, 2016. URL http://arxiv.org/ abs/1609.04309.
+
+Karthik A. Jagadeesh, Johannes Birgmeier, Harendra Guturu, Cole A. Deisseroth, Aaron M. Wenger, Jonathan A. Bernstein, and Gill Bejerano. Phrank measures phenotype sets similarity to greatly improve mendelian diagnostic disease prioritization. Genetics in Medicine, 2018.
+
+ISSN 1530-0366. doi: 10.1038/s41436-018-0072-y. URL https://doi.org/10.1038/ s41436-018-0072-y.
+
+Yoon Kim. Convolutional neural networks for sentence classification. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1746–1751. Association for Computational Linguistics, 2014. doi: 10.3115/v1/D14-1181. URL http: //www.aclweb.org/anthology/D14-1181.
+
+Maxat Kulmanov, Mohammed Asif Khan, and Robert Hoehndorf. Deepgo: predicting protein functions from sequence and interactions using a deep ontology-aware classifier. In Bioinformatics, 2018.
+
+Liang Lan, Nemanja Djuric, Yuhong Guo, and Slobodan Vucetic. Ms-knn: protein function prediction by integrating multiple data sources. BMC Bioinformatics, 14(S-3):S8, 2013.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. CoRR, abs/1310.4546, 2013. URL http://arxiv.org/abs/1310.4546.
+
+Riccardo Miotto, Li Li, Brian A Kidd, and Joel T Dudley. Deep patient: an unsupervised representation to predict the future of patients from the electronic health records. Scientific reports, 6: 26094, 2016.
+
+Frederic Morin and Yoshua Bengio. Hierarchical probabilistic neural network language model. In Robert G. Cowell and Zoubin Ghahramani (eds.), Proceedings of the Tenth International Workshop on Artificial Intelligence and Statistics, pp. 246–252. Society for Artificial Intelligence and Statistics, 2005. URL http://www.iro.umontreal.ca/˜lisa/pointeurs/ hierarchical-nnlm-aistats05.pdf.
+
+Judea Pearl. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann, 1988.
+
+Stuart Russell and Peter Norvig. Artificial Intelligence: A Modern Approach. Prentice Hall Press, Upper Saddle River, NJ, USA, 3rd edition, 2009. ISBN 0136042597, 9780136042594.
+
+David L. Wheeler, Tanya Barrett, Dennis A. Benson, Stephen H. Bryant, Kathi Canese, Vyacheslav Chetvernin, Deanna M. Church, Michael DiCuccio, Ron Edgar, Scott Federhen, Lewis Y. Geer, Yuri Kapustin, Oleg Khovayko, David Landsman, David J. Lipman, Thomas L. Madden, Donna R. Maglott, James Ostell, Vadim Miller, Kim D. Pruitt, Gregory D. Schuler, Edwin Sequeira, Steven T. Sherry, Karl Sirotkin, Alexandre Souvorov, Grigory Starchenko, Roman L. Tatusov, Tatiana A. Tatusova, Lukas Wagner, and Eugene Yaschenko. Database resources of the national center for biotechnology information. Nucleic Acids Research, 35:D5–D12, 2007. doi: 10.1093/nar/gkl1031. URL http://dx.doi.org/10.1093/nar/gkl1031.
+
+# A APPENDIX
+
+A.1 HYPERPARAMETER GRID AND BEST HYPERPARAMETERS
+
+Table 2: Hyperparameter space explored for small disease prediction   
+
+<table><tr><td>Hyperparameter Name</td><td>ValuesExplored</td></tr><tr><td>Learning Rate</td><td>[10-²,10-3,10-4,10-5,10-6]</td></tr><tr><td>Embedding Size</td><td>[64,128,256, 512]</td></tr><tr><td>Number Of Additional Layers</td><td>[0, 1, 2]</td></tr><tr><td>Additional Layer Size</td><td>[128,256, 512]</td></tr><tr><td>Activation function</td><td>[identity, ReLU]</td></tr><tr><td>Shared Weights</td><td>[False,True]</td></tr></table>
+
+Table 3: Best hyperparameters for small disease prediction   
+
+<table><tr><td>Hyperparameter Name</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>Learning Rate</td><td>10-5</td><td>10-4</td></tr><tr><td>Embedding Size</td><td>512</td><td>256</td></tr><tr><td>Number Of Additional Layers</td><td>0</td><td>0</td></tr><tr><td>Layer Size</td><td>N/A</td><td>N/A</td></tr><tr><td>Activation function</td><td>identity</td><td>identity</td></tr><tr><td>Shared Weights</td><td>True</td><td>True</td></tr></table>
+
+Table 4: Hyperparameter space explored for large disease prediction   
+
+<table><tr><td>Hyperparameter Name</td><td>Values Explored</td></tr><tr><td>Learning Rate</td><td>[10-3,10-4,10-5]</td></tr><tr><td>Embedding Size</td><td>[256, 512]</td></tr><tr><td>Number Of Additional Layers</td><td>[0,1,2]</td></tr><tr><td>Additional Layer Size</td><td>[128,256,512]</td></tr><tr><td>Activation function</td><td>[identity,ReLU]</td></tr><tr><td>Shared Weights</td><td>[False, True]</td></tr></table>
+
+Table 5: Best hyperparameters for large disease prediction   
+
+<table><tr><td>Hyperparameter Name</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>Learning Rate</td><td>10-4</td><td>10-4</td></tr><tr><td>Embedding Size</td><td>512</td><td>512</td></tr><tr><td>Number Of Additional Layers</td><td>0</td><td>0</td></tr><tr><td>Layer Size</td><td>N/A</td><td>N/A</td></tr><tr><td>Activation function</td><td>ReLU</td><td>identity</td></tr><tr><td>Shared Weights</td><td>True</td><td>True</td></tr></table>
+
+Table 6: Hyperparameter space explored for protein function prediction   
+
+<table><tr><td>Learning Rate Hyperparameter Name</td><td>[10-1,10-²,10-3,10-4,10-5] Values Explored</td></tr><tr><td>Embedding Size</td><td>[64,128,256]</td></tr><tr><td>Middle Layer Size</td><td>[128, 256, 512]</td></tr><tr><td>Keep Probability</td><td>[0.5, 0.7, 0.8, 0.9, 1.0]</td></tr></table>
+
+Table 7: Best hyperparameters for protein function prediction   
+
+<table><tr><td>Hyperparameter Name</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>Learning Rate</td><td>10-3</td><td>10-3</td></tr><tr><td>Embedding Size</td><td>64</td><td>128</td></tr><tr><td>Middle Layer Size</td><td>512</td><td>512</td></tr><tr><td>Keep Probability</td><td>0.7</td><td>0.7</td></tr></table>
+
+A.2 BINNED PER-LABEL PERFORMANCE NUMBERS FOR LESS FREQUENT LABELS   
+Table 8: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the small disease prediction task.   
+
+<table><tr><td rowspan="2">Number of Positive Examples</td><td colspan="3">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.66 (0.65-0.66)</td><td>0.68 (0.68-0.68)</td><td>0.77 (0.77-0.77)</td></tr><tr><td>5-10</td><td>0.66 (0.65-0.66)</td><td>0.68 (0.68-0.68)</td><td>0.77 (0.77-0.77)</td></tr><tr><td>11-25</td><td>0.74 (0.74-0.74)</td><td>0.70 (0.70-0.70)</td><td>0.79 (0.79-0.80)</td></tr><tr><td>26-50</td><td>0.78 (0.78-0.79)</td><td>0.72 (0.72-0.72)</td><td>0.81 (0.80-0.81)</td></tr><tr><td>51-100</td><td>0.80 (0.79-0.80)</td><td>0.74 (0.74-0.74)</td><td>0.81 (0.80-0.81)</td></tr><tr><td>101-250</td><td>0.81 (0.81-0.81)</td><td>0.76 (0.76-0.76)</td><td>0.81 (0.81-0.81)</td></tr><tr><td>251-500</td><td>0.82 (0.82-0.82)</td><td>0.77 (0.77-0.77)</td><td>0.81 (0.80-0.81)</td></tr><tr><td>501-1000</td><td>0.83 (0.83-0.83)</td><td>0.80 (0.79-0.80)</td><td>0.82 (0.82-0.82)</td></tr></table>
+
+Table 9: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the small disease prediction task.   
+
+<table><tr><td rowspan="2">Number of Positive Examples</td><td colspan="3">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.09 (0.08-0.09)</td><td>0.06 (0.06-0.07)</td><td>0.23 (0.22-0.23)</td></tr><tr><td>11-25</td><td>0.11 (0.10-0.11)</td><td>0.04 (0.04-0.04)</td><td>0.19 (0.19-0.19)</td></tr><tr><td>26-50</td><td>0.10 (0.10-0.11)</td><td>0.04 (0.04-0.04)</td><td>0.15 (0.15-0.15)</td></tr><tr><td>51-100</td><td>0.08 (0.08-0.09)</td><td>0.04 (0.04-0.04)</td><td>0.12 (0.11-0.12)</td></tr><tr><td>101-250</td><td>0.08 (0.08-0.08)</td><td>0.05 (0.04-0.05)</td><td>0.10 (0.09-0.10)</td></tr><tr><td>251-500</td><td>0.08 (0.08-0.08)</td><td>0.06 (0.06-0.06)</td><td>0.09 (0.09-0.09)</td></tr><tr><td>501-1000</td><td>0.10 (0.10-0.10)</td><td>0.09 (0.09-0.09)</td><td>0.11 (0.11-0.11)</td></tr></table>
+
+Table 10: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the large disease prediction task.   
+
+<table><tr><td rowspan="2">Number of Positive Examples</td><td colspan="3">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.45 (0.42-0.48)</td><td>0.69 (0.66-0.72)</td><td>0.71 (0.68-0.73)</td></tr><tr><td>11-25</td><td>0.50 (0.48-0.51)</td><td>0.75 (0.74-0.77)</td><td>0.76 (0.74-0.78)</td></tr><tr><td>26-50</td><td>0.67 (0.65-0.68)</td><td>0.79 (0.77-0.80)</td><td>0.79 (0.77-0.80)</td></tr><tr><td>51-100</td><td>0.76 (0.76-0.77)</td><td>0.80 (0.80-0.81)</td><td>0.81 (0.80-0.82)</td></tr><tr><td>101-250</td><td>0.81 (0.81-0.82)</td><td>0.82 (0.82-0.83)</td><td>0.82 (0.82-0.82)</td></tr><tr><td>251-500</td><td>0.83 (0.82-0.83)</td><td>0.83 (0.83-0.84)</td><td>0.84 (0.83-0.84)</td></tr><tr><td>501-1000</td><td>0.85 (0.85-0.85)</td><td>0.85 (0.85-0.85)</td><td>0.85 (0.85-0.85)</td></tr></table>
+
+Table 11: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the large disease prediction task.   
+
+<table><tr><td rowspan="2">Number of Positive Examples</td><td colspan="3">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.08 (0.05-0.11)</td><td>0.33 (0.28-0.37)</td><td>0.38 (0.34-0.43)</td></tr><tr><td>11-25</td><td>0.11 (0.10-0.13)</td><td>0.38 (0.36-0.41)</td><td>0.43 (0.40-0.46)</td></tr><tr><td>26-50</td><td>0.25 (0.23-0.27)</td><td>0.42 (0.39-0.44)</td><td>0.45 (0.43-0.47)</td></tr><tr><td>51-100</td><td>0.33 (0.32-0.35)</td><td>0.39 (0.37-0.40)</td><td>0.43 (0.42-0.45)</td></tr><tr><td>101-250</td><td>0.35 (0.34-0.36)</td><td>0.36 (0.35-0.37)</td><td>0.39 (0.38-0.39)</td></tr><tr><td>251-500</td><td>0.31 (0.30-0.32)</td><td>0.32 (0.31-0.33)</td><td>0.35 (0.35-0.36)</td></tr><tr><td>501-1000</td><td>0.29 (0.29-0.30)</td><td>0.29 (0.28-0.29)</td><td>0.32 (0.31-0.32)</td></tr></table>
+
+Table 12: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task.   
+
+<table><tr><td rowspan="2">Number of Positive Examples</td><td colspan="3">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.62 (0.60-0.63)</td><td>0.73 (0.71-0.75)</td><td>0.80 (0.79-0.82)</td></tr><tr><td>11-25</td><td>0.61 (0.60-0.62)</td><td>0.74 (0.72-0.76)</td><td>0.80 (0.79-0.82)</td></tr><tr><td>26-50</td><td>0.63 (0.61-0.64)</td><td>0.77 (0.75-0.79)</td><td>0.80 (0.78-0.82)</td></tr><tr><td>51-100</td><td>0.63 (0.62-0.65)</td><td>0.78 (0.76-0.79)</td><td>0.81 (0.79-0.82)</td></tr><tr><td>101-250</td><td>0.64 (0.63-0.65)</td><td>0.77 (0.75-0.78)</td><td>0.79 (0.78-0.81)</td></tr><tr><td>251-500</td><td>0.64 (0.63-0.65)</td><td>0.76 (0.75-0.78)</td><td>0.78 (0.77-0.79)</td></tr><tr><td>501-1000</td><td>0.65 (0.64-0.66)</td><td>0.75 (0.74-0.77)</td><td>0.77 (0.76-0.78)</td></tr></table>
+
+Table 13: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task.   
+
+<table><tr><td rowspan="2">Number of Positive Examples</td><td colspan="3">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.19 (0.17-0.22)</td><td>0.16 (0.14-0.18)</td><td>0.23 (0.21-0.26)</td></tr><tr><td>11-25</td><td>0.15 (0.13-0.17)</td><td>0.18 (0.17-0.20)</td><td>0.21 (0.19-0.23)</td></tr><tr><td>26-50</td><td>0.13 (0.11-0.15)</td><td>0.21 (0.18-0.23)</td><td>0.21 (0.19-0.23)</td></tr><tr><td>51-100</td><td>0.12 (0.11-0.14)</td><td>0.21 (0.19-0.23)</td><td>0.20 (0.18-0.22)</td></tr><tr><td>101-250</td><td>0.12 (0.10-0.13)</td><td>0.21 (0.19-0.23)</td><td>0.21 (0.20-0.23)</td></tr><tr><td>251-500</td><td>0.12 (0.11-0.14)</td><td>0.22 (0.20-0.24)</td><td>0.22 (0.20-0.23)</td></tr><tr><td>501-1000</td><td>0.16 (0.15-0.18)</td><td>0.27 (0.25-0.29)</td><td>0.27 (0.25-0.29)</td></tr></table>
+
+A.3 PROTEIN REWEIGHTED FLAT SIGMOID BASELINE BINNED PER-LABEL PERFORMANCENUMBERS FOR LESS FREQUENT LABELS
+
+Table 14: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task with the reweighted flat sigmoid baseline.   
+
+<table><tr><td>Number of Positive Examples</td><td>Reweighted Flat Sigmoid</td></tr><tr><td>5-10</td><td>0.76 (0.74-0.77)</td></tr><tr><td>11-25</td><td>0.76 (0.74-0.78)</td></tr><tr><td>26-50</td><td>0.77 (0.76-0.79)</td></tr><tr><td>51-100</td><td>0.79 (0.77-0.80)</td></tr><tr><td>101-250</td><td>0.78 (0.76-0.79)</td></tr><tr><td>251-500</td><td>0.77 (0.76-0.79)</td></tr><tr><td>501-1000</td><td>0.77 (0.75-0.78)</td></tr></table>
+
+Table 15: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task with the reweighted flat sigmoid baseline.   
+
+<table><tr><td>Number of Positive Examples</td><td>Reweighted Flat Sigmoid</td></tr><tr><td>5-10</td><td>0.14 (0.12-0.16)</td></tr><tr><td>11-25</td><td>0.16 (0.14-0.18)</td></tr><tr><td>26-50</td><td>0.17 (0.17-0.22)</td></tr><tr><td>51-100</td><td>0.22 (0.19-0.23)</td></tr><tr><td>101-250</td><td>0.22 (0.20-0.24)</td></tr><tr><td>251-500</td><td>0.22 (0.21-0.24</td></tr><tr><td>501-1000</td><td>0.27 (0.25-0.29)</td></tr></table>

parse/train/r1g1LoAcFm/r1g1LoAcFm_content_list.json

@@ -0,0 +1,1319 @@
+[
+    {
+        "type": "text",
+        "text": "USING ONTOLOGIES TO IMPROVE PERFORMANCE IN MASSIVELY MULTI-LABEL PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Massively multi-label prediction/classification problems arise in environments like health-care or biology where it is useful to make very precise predictions. One challenge with massively multi-label problems is that there is often a longtailed frequency distribution for the labels, resulting in few positive examples for the rare labels. We propose a solution to this problem by modifying the output layer of a neural network to create a Bayesian network of sigmoids which takes advantage of ontology relationships between the labels to help share information between the rare and the more common labels. We apply this method to the two massively multi-label tasks of disease prediction (ICD-9 codes) and protein function prediction (Gene Ontology terms) and obtain significant improvements in per-label AUROC and average precision. ",
+        "bbox": [
+            233,
+            273,
+            764,
+            428
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            336,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study general techniques for improving predictive performance in massively multilabel classification/prediction problems in which there is an ontology providing relationships between the labels. Such problems have practical applications in biology, precision health, and computer vision where there is a need for very precise categorization. For example, in health care we have an increasing number of treatments that are only useful for small subsets of the patient population. This forces us to create large and precise labeling schemes when we want to find patients for these personalized treatments. ",
+        "bbox": [
+            174,
+            513,
+            823,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One large issue with massively multi-label prediction is that there is often a long-tailed frequency distribution for the labels with a large fraction of the labels having very few positive examples in the training data. The corresponding low amount of training data for rare labels makes it difficult to train individual classifiers. Current multi-task learning approaches enable us to somewhat circumvent this bottleneck through sharing information between the rare and cofmmon labels in a manner that enables us to train classifiers even for the data poor rare labels (Caruana, 1997). ",
+        "bbox": [
+            174,
+            617,
+            823,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce a new method for massively multi-label prediction, a Bayesian network of sigmoids, that helps achieve better performance on rare classes by using ontological information to better share information between the rare and common labels. This method is based on similar ideas found in Bayesian networks and hierarchical softmax (Morin & Bengio, 2005). The main distinction between this paper and prior work is that we focus on improving multi-label prediction performance with more complicated directed acyclic graph (DAG) structures between the labels while previous hierarchical softmax work focuses on improving runtime performance on multi-class problems (where labels are mutually exclusive) with simpler tree structures between the labels. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In order to demonstrate the empirical predictive performance of our method, we test it on two very different massively multi-label tasks. The first is a disease prediction task where we predict ICD-9 (diagnoses) codes from medical record data using the ICD-9 hierarchy to tie the labels together. The second task is a protein function prediction task where we predict Gene Ontology terms (Ashburner et al., 2000; Carbon et al., 2017) from sequence information using the Gene Ontology DAG to combine the labels. Our experiments indicate that our new method obtains better average predictive performance on rare labels while maintaining similar performance on common labels. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            290,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 PROBLEM SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            132,
+            333,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal of multi-label prediction is to learn the distribution $P ( L | X )$ which gives the probability of an instance $X$ having a label $L$ from a dictionary of $N$ labels. We are particularly interested in the case where there is an ontology providing superclass relationships between the labels. This ontology consists of a DAG where every label $L$ is a node and every directed edge from $L _ { i }$ to $L _ { j }$ indicates that the label $L _ { i }$ is a superclass of the label $L _ { j }$ . Figure 1 gives corresponding example simplified subgraphs from both the ICD-9 hierarchy and the Gene Ontology DAG. We define parents ${ \\bf \\nabla } \\cdot ( L )$ to be the direct parents of $L$ . We define ancestor $s ( L )$ to be all of the nodes that have a directed path to $L$ . ",
+        "bbox": [
+            173,
+            159,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/93446a772d4b23aee07a1ac3b0b24cc501ecef1c47e60ba99e246db593e63a31.jpg",
+        "image_caption": [
+            "Figure 1: Example simplified graphs showing superclass relationships from the ICD-9 hierarchy and the Gene Ontology DAG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            282,
+            813,
+            441
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The classical approach for solving this problem is to learn separate functions for each label. This transforms the problem into $N$ binary prediction problems which can each be solved with standard techniques. The main issue with this approach is that it is less sample efficient in that it does not share information between the labels. A more sophisticated approach is to use multi-task learning techniques to share information between the individual label-specific binary classifiers. One approach for doing this with neural networks is to introduce shared layers between the different binary classifiers. The resulting output layer is a flat structure of sigmoid outputs, with each sigmoid output representing one $P ( L | X )$ . This reduces the number of parameters needed for every label and allows information to be shared among the labels (Caruana, 1997). However, even with this weight sharing, the final output layer still needs to be learned independently for each label. ",
+        "bbox": [
+            173,
+            506,
+            825,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 BAYESIAN NETWORK FACTORIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            482,
+            675
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a modification of the output layer by constructing a Bayesian network of sigmoids in order to use the ontology to share additional information between labels in a more guided way. The general idea is that we assume that the probability of our labels follows a Bayesian network (Pearl, 1988) with each edge in the ontology representing an edge within the Bayesian network. This, along with the fact that the edges denote superclasses, enables us to factor the probability of a label into several conditional probabilities. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            771
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66cc75d9225bb244ac84320d72a7364d0caa157bdef68479fa7b8e013a245941.jpg",
+        "text": "$$\n\\begin{array} { l } { { P ( L | X ) = P ( L , a n c e s t o r s ( L ) | X ) } } \\\\ { { \\ } } \\\\ { { \\displaystyle = \\prod _ { \\ell \\in \\{ L \\} \\cup a n c e s t o r s ( L ) } P ( \\ell | X , p a r e n t s ( \\ell ) ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            197,
+            790,
+            540,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As the edges denote superclasses, having a child label implies having every ancestor ",
+        "bbox": [
+            562,
+            795,
+            797,
+            837
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "From Baysian network assumption on the subgraph consisting of $L$ and ancestor ${ \\bf \\nabla } ^ { \\mathrm { * } } ( L )$ (Pearl, 1988) ",
+        "bbox": [
+            560,
+            843,
+            797,
+            886
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We are now able to learn the conditional probability distributions $P ( L | X , p a r e n t s ( L ) )$ for every label in the ontology and use the above formula to reconstruct the final target probabilities ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "$P ( L | X )$ . Consider the example simplified ICD-9 graph in Figure 1. For this graph, we would learn $P ( C a n c e r | X ) , P ( L u n g C a n c e r | C a n c e r , X )$ , and $P ( S k i n C a n c e r | C a n c e r , X )$ . We would then be able to compute $P ( L u n g C a n c e r | X ) = P ( C a n c e r | X ) \\times P ( L u n g C a n c e r | C a n c e r , X ) .$ ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The intuition of why this factoring might be useful is that it enables the transferring of knowledge from more common higher-level labels to more rare lower-level labels. Consider the case where $L$ is very rare. In that case it is difficult to learn $P ( L | X )$ directly due to the small amount of training data. However, the decomposed version $\\begin{array} { r } { \\prod _ { \\ell \\in \\{ L \\} \\cup a n c e s t o r s ( L ) } P ( \\ell | X , p a r e n t s ( \\ell ) ) } \\end{array}$ includes classifiers from the ancestors of $L$ that have more training data and might be easier to learn. This factoring allows additional signal from the better trained higher-level labels to feed directly into the probability computation for the rare leaf $L$ . If we can rule out one of the higher-level labels, we can also rule out a lower-level label. For example, consider the ICD-9 graph illustrated in Figure 1. We might not have enough patients with lung cancer to directly learn an optimal $P ( L u n g C a n c e r | X )$ . However, we can pool all of our cancer patients to learn a hopefully more optimal $P ( C a n c e r | X )$ . We can then use our Bayesian network factoring to incorporate the better trained $P ( C a n c e r | X )$ classifier in our calculation for $P ( L u n g C a n c e r | X )$ . In our experiments we show that this intuition plays out in practice through improved performance on rare labels. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Bayesian network assumption plays an important role in allowing us to factor the probabilities in this manner. In order to perform our factoring, we must assume that every subgraph of the ontology consisting of the nodes $\\{ L \\} \\cup a n c e s t o r s ( L )$ correctly represents a Bayesian network for the label probability distribution. These subgraphs are only correct Bayesian networks if the probability of every label $L$ is conditionally independent of the probabilities of non-descendent labels given the parent labels and $X$ (Russell & Norvig, 2009). This might seem somewhat limiting, but there are two reasons why this assumption is weaker than it might appear. First, we only require a Bayesian network to be correct for the subgraphs of the form $\\{ L \\} \\cup a n c e s t o r s ( L )$ . This is true because we only consider the nodes $\\{ L \\} \\cup a n c e s t o r s ( L )$ when we do our factoring. This is a significantly weaker assumption than requiring the entire graph to follow a Bayesian network. One direct application of this is that every tree ontology can meet this assumption. The proof for this is that every $\\{ L \\} \\cup a n c e s t o r s ( L )$ subgraph of a tree is a simple chain. A simple chain is not able to violate the conditional independence assumption behind Bayesian networks because it has no non-descendent nodes that are not already ancestors. Ancestor nodes are always conditionally independent with the label given the parents because the edges represent superclasses and thus either the ancestors are always present if the parent i present or the label is always not present if the parent is not present. The second reason why this assumption is weaker than it might appear is that we only require conditional independence given a particular instance $X$ . As an illustrative example, consider the two ICD-9 labels of male breast cancer (ICD-9 175) and female breast cancer (ICD-9 174). Male breast cancer and female breast cancer are trivially not conditionally independent due to the gender qualifier making them mutually exclusive. However, male breast cancer and female breast cancer become conditionally independent once you condition on the gender of the patient. Thus conditioning on the exact instance $X$ enables more conditional independence than would otherwise be available. Nevertheless, even with these caveats, there will be some circumstances in which this conditional independence assumption is violated. In these situations, our factoring is not valid and our computed product $\\Pi _ { \\ell \\in \\{ L \\} \\cup a n c e s t o r s ( L ) } P ( \\ell | X , p a r e n t s ( \\ell ) )$ might diverge from the actual $P ( L | X )$ . Yet, even in these situations, the resulting scores can still be empirically useful. We demonstrate that this is the case in our experiments by showing performance improvements in a protein function prediction task that almost assuredly violates this conditional independence assumption. ",
+        "bbox": [
+            173,
+            343,
+            825,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 MODELING THE PROBABILITIES WITH SIGMOID ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            770,
+            549,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are many potential ways in which the conditional probabilities $P ( L | X , p a r e n t s ( L ) )$ could be modeled. We exclusively focus on modeling these probabilities using a sigmoid function computed on logits from neural networks. We define an encoder neural network for every task that takes in the input $X$ and returns a fixed-length representation of the input. We also define a fixed-length embedding for every label $L$ by constructing an output embedding matrix such that $e _ { L }$ is the embedding for $L$ . This encoder and label embedding then allow us to model $P ( L | X , p a r e n t s ( L ) )$ as $\\sigma ( e n c o d e r ( X ) \\cdot e _ { L } )$ , where $\\sigma$ indicates the sigmoid function and $\\ast$ indicates a dot product. Note that $p a r e n t s ( L )$ is not used in this formula. This is because there is a unique set of parents for every label $L$ , so there is no need to have distinct $e _ { L }$ vectors for different sets of parents. We can then train ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$P ( L | X , p a r e n t s ( L ) )$ by using cross entropy loss on patients who have all the labels in parent ${ \\mathfrak { s } } ( L )$ . Note that we explicitly do not train each of the conditional probabilities on every patient. We can only train the conditional probabilities on patients who satisfy the conditional requirement of having the parent labels. This does not change the number of positive examples for each classifier, but it does significantly reduce the number of negative examples for the lower level classifiers. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For example, consider the ICD-9 subgraph shown in Figure 1. In this situation, we have three labels and thus need to learn three conditional probabilities: $\\bar { P ( } C a n c e r | X ) , P ( L u n g C a n c e r | C a n c e r , X )$ and $P ( B r e a s t C a n c e r | C a n c e r , X )$ . We have three labels, so our label embedding matrix consists of $e _ { C a n c e r }$ , eLungCancer and eBreastCancer. We can now compute $P ( L u n g C a n c e r | X )$ and $P ( B r e a s t C a n c e r | X )$ as follows: ",
+        "bbox": [
+            174,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2e9cba1210518a68420a3c1990b50c5ff294ece746d9024e06e847411e53c520.jpg",
+        "text": "$$\n\\begin{array} { r } { P ( L u n g C a n c e r | X ) = P ( L u n g C a n c e r | C a n c e r , X ) \\times P ( C a n c e r | X ) \\phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } \\\\ { = \\sigma ( e n c o d e r ( X ) \\cdot e _ { L u n g C a n c e r } ) \\times \\sigma ( e n c o d e r ( x ) \\cdot e _ { C a n c e r } ) \\phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            273,
+            772,
+            310
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ffecf681a29d7c68842423d1afe4b575d0ce5fcdbf22952e993ac1fcade2ecd.jpg",
+        "text": "$$\n\\begin{array} { r l } & { P ( B r e a s t C a n c e r | X ) = P ( B r e a s t C a n c e r | C a n c e r , X ) \\times P ( C a n c e r | X ) } \\\\ & { \\quad \\quad = \\sigma ( e n c o d e r ( X ) \\cdot e _ { B r e a s t C a n c e r } ) \\times \\sigma ( e n c o d e r ( X ) \\cdot e _ { C a n c e r } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            330,
+            787,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As a baseline, we also train models with a normal flat sigmoid output layer. In these models we directly learn $P ( L | X )$ for each label. Similar to the conditional probabilities, we can define these probabilities as a sigmoid of the output from a neural network. We define $P ( L | X )$ to be $\\sigma ( e n c o d e r ( X ) \\cdot e _ { L } )$ . We can then train $P ( L | X )$ using cross entropy loss on all patients. ",
+        "bbox": [
+            173,
+            375,
+            826,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            450,
+            398,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We evaluated the predictive performance of our method on two very different massively multi-label problems. We consider the task of predicting future diseases for patients given medical history in the form of ICD-9 codes and the task of predicting protein function from sequence data in the form of Gene Ontology terms. In this section, we introduce the datasets, encoders and baselines used for each problem. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DISEASE PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            566,
+            367,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            299,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One of our experiments consists of predicting diseases in the form of ICD-9 codes from electronic medical record (EMR) data. We have two years and nine months of data covering 2013, 2014, and the first nine months of 2015. We use two years of history to predict which ICD-9 codes will appear in the following nine months. The problem setup for this experiment closely matches the setup in Miotto et al. (2016). We use a large insurance claims dataset from [redacted to preserve anonymity] for modeling. Our claims data consists of diagnoses (ICD-9), medications (NDC), procedures (CPT), and some metadata such as age, gender, location, general occupation, and employment status. We restrict our analysis to patients who were enrolled during 2013, 2014 and January 2015. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We have 15.7 million patients, of which a random $5 \\%$ are used for validation and $5 \\%$ are used for testing. This dataset is quite large, much larger than what is usually available in a hospital. Thus we consider two cases of this problem. The “high data case” is where we use all remaining 14.1 million patients for training. The “ low data case” consists of training with a $2 \\%$ random sample of 281,874 patients and is much closer in size to normal hospital datasets (Choi et al., 2017; Avati et al., 2017). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our target label dictionary for this task consists of all leaf ICD-9 billing codes that appear at least 5 times in the training data. We only predict leaf codes as those are the only codes allowed for billing and thus the only ICD-9 codes that records are annotated with. This results in a dictionary of 6,902 codes for the small disease prediction task and 12,533 codes for the large disease prediction task. We use the ICD-9 hierarchy included in the 2018AA UMLS release (Bodenreider, 2004) in order to construct relationships between the labels for our method. We additionally use the CPT and ATC ontologies included in the 2018AA for our encoder. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/de4256377e4fd9a15604d571ab33bf83b7c5ffe62895b56258821e735f97412c.jpg",
+        "image_caption": [
+            "Figure 2: The partitioning of the patient timelines into input history and output prediction labels as well as the subpartioning of the input history into time-bins. Each tick on the $\\mathbf { X }$ -axis represents one month. The first two years of information is used as input and the final nine months is used to generate output prediction labels. These first two years are subdivided into six bins of the following lengths for featurization: one year, six months, three months, one month, one month, and one month. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            821,
+            194
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 ENCODER DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            310,
+            398,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For our encoder, we use a feed-forward architecture inspired by Avati et al. (2017). As in their model, we split our two years of data into time-sliced bins. For each time slice, we find all the ICD-9, NDC and CPT codes that the patient experienced during the time slice. Figure 2 details the exact layout of each time bin. We also add a feature for every higher-level code in the ICD-9, ATC and CPT ontologies that indicates whether the patient had any of the descendants of that particular code within the time slice. This expanded rollup scheme is structurally very similar to the subword method introduced in Bojanowski et al. (2017). The weights for these input embeddings are tied to the output embedding matrix used in our output layers. We summarize the set of embeddings for each time bin using mean pooling. We also construct mean embedding for the metadata by feeding the metadata entries through an embedding matrix followed by mean pooling. Finally, we concatenate the means from each timeslice with the mean embeddings from the metadata and feed the resulting vector into a feedforward neural network to compute a final patient embedding. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These neural network models are trained with the Adam optimizer. The hyperparameters such as the learning rate, layer size, non-linearity, and number of layers are optimized using a grid search on the validation set. Appendix A.1 has details on the space searched as well as the best hyper-parameters for both the normal sigmoid and Bayesian network sigmoid models. ",
+        "bbox": [
+            176,
+            511,
+            825,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, as a further baseline, we also train logistic regression models individually for several rare ICD-9 codes. These models are trained on a binary matrix where each row represents a patient and each column represents an ICD-9 code, NDC code, CPT code, or metadata element. A particular row and column element is set to 1 whenever a patient has that particular item in the metadata or during the two years of provided medical history. These logistic regression models are regularized with L2 with a lambda optimized using cross-validation. One particular issue with training individual models on rare codes is that the dataset is distinctly unbalanced with vastly more negative examples than positive examples. We deal with this issue by subsampling negative examples so that the ratio of positive and negative samples is 1:10. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 PROTEIN FUNCTION PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            444,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            297,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For our other experiment, we predict protein functions in the form of Gene Ontology (GO) terms from sequence data. We focus only on human proteins that have at least one Gene Ontology annotation. Our features consist of amino acid sequences downloaded from Uniprot on July 27, 2018 (Consortium, 2017). For our labels, we use the human GO labels which were generated on June 18, 2018. After joining the labels with the sequence data, we have a total of 15,497 annotated human protein sequences. A random $80 \\%$ of the sequences are used for training, $10 \\%$ are using for validation, and a final $10 \\%$ are used for final testing. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this task we predict all leaf and higher level GO terms that appear at least 5 times in the training data. This results in a target dictionary of 7,751 terms. We construct relationships between these labels using the July 24, 2018 release of the GO basic ontology. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 ENCODER DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            397,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use Kim (2014)’s 1-D CNN based encoder to encode our protein sequence information. We treat every letter in the alphabet as a word and encode each of those letters with an embedding size of size 26. We then apply a 1-D convolution with a window size of 8 over the embedded sequence. A fixed-length representation of the protein is then obtained by doing max-over-time pooling. This representation is finally fed through a ReLU and one fully connected layer. The resulting fixed dimension vector is the encoded protein. For regularization, we add dropout before the convolution and fully connected layer. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following previous work, we also consider generating features using sequence alignment (Kulmanov et al., 2018). We use version 2.7.1 of the BLAST tool to find the most similar training set protein for every protein in our dataset (Wheeler et al., 2007). We then use this most similar protein to augment our protein encoder by adding a binary feature which signifies if the most similar protein has the particular term we are predicting. ",
+        "bbox": [
+            174,
+            241,
+            823,
+            310
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "These CNN models are trained with Adam. Hyperparameters such as learning rate, number of filters, dropout, and the size of the final layer are optimized using a grid search on the validation set. See Appendix A.1 for a full listing of the space searched as well as the best hyperparameters for both the flat sigmoid and Bayesian network of sigmoids models. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a further baseline, we also consider using the BLAST features alone for predicting protein function. This model simply consists of a 1 if the most similar protein has the target term or a 0 otherwise. ",
+        "bbox": [
+            173,
+            380,
+            823,
+            409
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For these protein models, we also consider one final baseline where we take our flat sigmoid model and weight labels according to the inverse square root of their frequency. This weighting scheme is based off the subsampling scheme from Mikolov et al. (2013). Unfortunately, this baseline did not seem to perform well on rare words so we did not consider it for the disease case and our more general analysis. The results for this baseline can be found in Appendix A.3. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            281,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows frequency binned per-label area under the receiver operating characteristic (AUROC) and average precision (AP) for less frequent labels that have at most 1,000 positive examples. See Appendix A.2 for the exact numerical results which include $95 \\%$ bootstrap confidence intervals generated through 500 bootstrap samples of the test set. As shown in Figure 4, these less frequent labels cover a majority of the labels within each dataset. Our results indicate that the Bayesian network of sigmoid output layer has better AUROC and average precision for rare labels in all three tasks, with the effect diminishing with increasing numbers of positive labels. This effect is especially strong in the average precision space. For example, the Bayesian network of sigmoid models obtain $187 \\%$ , $2 8 . 5 \\%$ and $1 7 . 9 \\%$ improvements in average precision for the rarest code bin (5-10 positive examples) over the baseline models for the small disease, large disease and protein function tasks, respectively. This improvement persists for the next rarest bin (11-25 positive examples), but decreases to $8 9 . 2 \\%$ , $1 0 . 7 \\%$ and $1 1 . 1 \\%$ . This matches our previous intuition as there is no need to transfer information from more general labels if there is enough data to model $P ( L | X )$ directly. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 compares micro-AUROC and micro-AP on all labels for all three tasks. The benefits of the Bayesian sigmoid output layer seem much more limited and task specific in this setting. We do not expect significantly better results in the micro averaged performance case because the micro results are more dominated by more frequent codes and the Bayesian network of sigmoids is only expected to help when $P ( L | X )$ does not have enough data to be modeled directly. The Bayesian network of sigmoids output layer provides better AUROC and AP for the disease prediction task, but suffers from worse performance in the protein function task. One possible explanation for this discrepancy is that our Bayesian network assumption is guaranteed to be correct in the disease prediction task due to the tree structure of the ontology, but might not be correct in the protein function task with its more complicated DAG ontological structue. It is possible that minor violations of the Bayesian network assumption in the protein function prediction task cause the overall performance to be worse on the more common code compared to the flat sigmoid decoder. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/95b0e5bef9f12fbfba98427c6bcafe0246ab83a571bbf99d8877253d79051d82.jpg",
+        "image_caption": [
+            "Figure 3: Frequency binned per-label AUROC and average precision (AP) for less frequent labels with at most 1,000 positive examples. AUROC and AP are calculated independently for each individual label. Labels are then grouped into bins determined by the number of positive samples per label and average statistics are computed for each bin. The $\\mathbf { X }$ -axis is in log-scale and represents the number of possible examples for the center of each bin. Each line represents the type of model, with the baseline model differing between the disease prediction and protein function prediction tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            818,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f00e571eb316dacfa60c9c169ba200c961b91d1a88abf101247c3d6814a0443.jpg",
+        "image_caption": [
+            "Figure 4: The cumulative frequency distribution for the target labels in the various tasks. The x-axis is in log scale. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            593,
+            818,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            862,
+            344,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There is related work on improved softmax variants, predicting ICD-9 codes, predicting Gene Ontology terms and combining ontologies with Bayesian networks. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e7c8bfeefe6e8188c4d4f182f77c11ae53c1c6e00f8dfbc970b38cd6e959c96b.jpg",
+        "table_caption": [
+            "Table 1: Micro-AUROC and micro-average precision (AP) results on the various tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Small Disease</td><td colspan=\"2\">Large Disease</td><td colspan=\"2\">Protein Function</td></tr><tr><td>AUROC</td><td>AP</td><td>AUROC</td><td>AP</td><td>AUROC</td><td>AP</td></tr><tr><td>Flat Sigmoid</td><td>0.951</td><td>0.209</td><td>0.982</td><td>0.262</td><td>0.945</td><td>0.436</td></tr><tr><td>Bayesian Network of Sigmoids</td><td>0.960</td><td>0.220</td><td>0.982</td><td>0.269</td><td>0.935</td><td>0.430</td></tr></table>",
+        "bbox": [
+            199,
+            131,
+            799,
+            228
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Improved softmax variants. There has been a wide variety of work focusing on trying to come up with improved softmax variants for use in massively multi-class problems such as language modeling. This prior work primarily differs from this work in that it focuses exclusively on the multi-class case with a tree structure connecting the labels. Multi-class is distinct from multi-label in that multi-class requires each item to only have one label while multi-label allows multiple labels per item. Most of this work focuses around trying to improve the training time for the expensive softmax operation found in multi-class problems such as large-vocabulary language modeling. The most related of these variants fall under the hierarchical softmax family. Hierarchical softmax from Morin & Bengio (2005) (and related versions such as class based softmax from Goodman (2001) and adaptive softmax from Grave et al. (2016)) focuses on speeding up softmax by using a tree structure to decompose the probability distribution. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            415
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Disease prediction. Previous work has also explored the task of disease prediction through predicting ICD-9 codes from medical record data (Miotto et al., 2016; Choi et al., 2017; 2015). GRAM from Choi et al. (2017) is a particularly relevant instance which uses the CCS hierarchy to improve the encoder, resulting in better predictions for rare codes. Our work differs from GRAM in that we improve the output layer while GRAM improves the encoder. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Protein function prediction. Protein function prediction in the form of Gene Ontology term prediction has been considered by previous work (Kulmanov et al., 2018; Lan et al., 2013; Cao et al., 2017). DeepGO from Kulmanov et al. (2018) is the most similar to the approach taken by this paper in that it uses a CNN on the sequence data to predict Gene Ontology terms. It also uses the ontology in that it creates a multi-task neural network in the shape of the ontology. Our work differs from DeepGO in that we focus on the rarer terms and we only modify the output layer. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Combining ontologies with Bayesian networks. Phrank from Jagadeesh et al. (2018) is an algorithm for computing similarity scores between sets of phenotypes for use in diagnosing genetic disorders. Like this paper, Phrank constructs a Bayesian network based on an ontology. This work differs from Phrank in that we focus on the supervised prediction task of modeling the probability of a label given an instance while Phrank focuses on the simpler task of modeling the unconditional probability of a label (or set of labels). ",
+        "bbox": [
+            174,
+            589,
+            823,
+            672
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            695,
+            318,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces a new method for improving the performance of rare labels in massively multi-label problems with ontologically structured labels. Our new method uses the ontological relationships to construct a Bayesian network of sigmoid outputs which enables us to express the probability of rare labels as a product of conditional probabilities of more common higher-level labels. This enables us to share information between the labels and achieve empirically better performance in both AUROC and average precision for rare labels than flat sigmoid baselines in three separate experiments covering the two very different domains of protein function prediction and disease prediction. This improvement in performance for rare labels enables us to make more precise predictions for smaller label categories and should be applicable to a variety of tasks that contain an ontology that defines relationships between labels. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            886,
+            326,
+            897
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This section has been redacted to preserve anonymity. ",
+        "bbox": [
+            176,
+            910,
+            527,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "M Ashburner, C A Ball, J A Blake, D Botstein, H Butler, J M Cherry, A P Davis, K Dolinski, S S Dwight, J T Eppig, M A Harris, D P Hill, L Issel-Tarver, A Kasarskis, S Lewis, J C Matese, J E Richardson, M Ringwald, G M Rubin, and G Sherlock. Gene ontology: tool for the unification of biology. the gene ontology consortium. Nat Genet, 25(1):25–29, May 2000. doi: 10.1038/75556. URL http://www.ncbi.nlm.nih.gov/pubmed/10802651. ",
+        "bbox": [
+            173,
+            126,
+            826,
+            195
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Avati, K. Jung, S. Harman, L. Downing, A. Ng, and N. H. Shah. Improving palliative care with deep learning. In 2017 IEEE International Conference on Bioinformatics and Biomedicine (BIBM), pp. 311–316, Nov 2017. doi: 10.1109/BIBM.2017.8217669. ",
+        "bbox": [
+            174,
+            204,
+            823,
+            247
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Olivier Bodenreider. The unified medical language system (umls): integrating biomedical terminology. Nucleic Acids Research, 32:D267–D270, 2004. doi: 10.1093/nar/gkh061. URL http://dx.doi.org/10.1093/nar/gkh061. ",
+        "bbox": [
+            176,
+            256,
+            823,
+            299
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. Enriching word vectors with subword information. Transactions of the Association for Computational Linguistics, 5:135–146, 2017. URL http://aclweb.org/anthology/Q17-1010. ",
+        "bbox": [
+            176,
+            308,
+            823,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Renzhi Cao, Colton Freitas, Leong Chan, Miao Sun, Haiqing Jiang, and Zhangxin Chen. Prolango: Protein function prediction using neural machine translation based on a recurrent neural network. Molecules, 22(10), 2017. ISSN 1420-3049. doi: 10.3390/molecules22101732. URL http: //www.mdpi.com/1420-3049/22/10/1732. ",
+        "bbox": [
+            173,
+            359,
+            826,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "S. Carbon, H. Dietze, S. E. Lewis, C. J. Mungall, M. C. Munoz-Torres, S. Basu, R. L. Chisholm, R. J. Dodson, P. Fey, Paul D. Thomas, H. Mi, A. Muruganujan, X. Huang, S. Poudel, J. C. Hu, S. A. Aleksander, B. K. McIntosh, D. P. Renfro, D. A. Siegele, G. Antonazzo, H. Attrill, N. H. Brown, S. J. Marygold, P. Mc-Quilton, L. Ponting, G. H. Millburn, A. J. Rey, R. Stefancsik, S. Tweedie, K. Falls, A. J. Schroeder, M. Courtot, D. Osumi-Sutherland, H. Parkinson, P. Roncaglia, R. C. Lovering, R. E. Foulger, R. P. Huntley, P. Denny, N. H. Campbell, B. Kramarz, S. Patel, J. L. Buxton, Z. Umrao, A. T. Deng, H. Alrohaif, K. Mitchell, F. Ratnaraj, W. Omer, M. Rodr´ıguezLopez, and The Gene Ontology Consortium. Expansion of the gene ontology knowledgebase and ´ resources: The gene ontology consortium. Nucleic Acids Research, 45(D1):D331–D338, 1 2017. ISSN 0305-1048. doi: 10.1093/nar/gkw1108. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana. Multitask learning. Machine learning, 28(1):41–75, 1997. ",
+        "bbox": [
+            173,
+            571,
+            655,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Edward Choi, Mohammad Taha Bahadori, and Jimeng Sun. Doctor AI: predicting clinical events via recurrent neural networks. CoRR, abs/1511.05942, 2015. URL http://arxiv.org/abs/ 1511.05942. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            638
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Edward Choi, Mohammad Taha Bahadori, Le Song, Walter F. Stewart, and Jimeng Sun. Gram: Graph-based attention model for healthcare representation learning. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’17, pp. 787–795, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4887-4. doi: 10.1145/ 3097983.3098126. URL http://doi.acm.org/10.1145/3097983.3098126. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The UniProt Consortium. Uniprot: the universal protein knowledgebase. Nucleic Acids Research, 45(D1):D158–D169, 2017. doi: 10.1093/nar/gkw1099. URL http://dx.doi.org/10. 1093/nar/gkw1099. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joshua Goodman. Classes for fast maximum entropy training. In Acoustics, Speech, and Signal Processing, 1988. ICASSP-88., 1988 International Conference on, volume 1, pp. 561 – 564 vol.1, 02 2001. ISBN 0-7803-7041-4. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Edouard Grave, Armand Joulin, Moustapha Cisse, David Grangier, and Herv ´ e J ´ egou. Efficient ´ softmax approximation for gpus. CoRR, abs/1609.04309, 2016. URL http://arxiv.org/ abs/1609.04309. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karthik A. Jagadeesh, Johannes Birgmeier, Harendra Guturu, Cole A. Deisseroth, Aaron M. Wenger, Jonathan A. Bernstein, and Gill Bejerano. Phrank measures phenotype sets similarity to greatly improve mendelian diagnostic disease prioritization. Genetics in Medicine, 2018. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ISSN 1530-0366. doi: 10.1038/s41436-018-0072-y. URL https://doi.org/10.1038/ s41436-018-0072-y. ",
+        "bbox": [
+            184,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1746–1751. Association for Computational Linguistics, 2014. doi: 10.3115/v1/D14-1181. URL http: //www.aclweb.org/anthology/D14-1181. ",
+        "bbox": [
+            176,
+            170,
+            825,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maxat Kulmanov, Mohammed Asif Khan, and Robert Hoehndorf. Deepgo: predicting protein functions from sequence and interactions using a deep ontology-aware classifier. In Bioinformatics, 2018. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            305
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Liang Lan, Nemanja Djuric, Yuhong Guo, and Slobodan Vucetic. Ms-knn: protein function prediction by integrating multiple data sources. BMC Bioinformatics, 14(S-3):S8, 2013. ",
+        "bbox": [
+            173,
+            343,
+            821,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. CoRR, abs/1310.4546, 2013. URL http://arxiv.org/abs/1310.4546. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Riccardo Miotto, Li Li, Brian A Kidd, and Joel T Dudley. Deep patient: an unsupervised representation to predict the future of patients from the electronic health records. Scientific reports, 6: 26094, 2016. ",
+        "bbox": [
+            174,
+            489,
+            823,
+            531
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Frederic Morin and Yoshua Bengio. Hierarchical probabilistic neural network language model. In Robert G. Cowell and Zoubin Ghahramani (eds.), Proceedings of the Tenth International Workshop on Artificial Intelligence and Statistics, pp. 246–252. Society for Artificial Intelligence and Statistics, 2005. URL http://www.iro.umontreal.ca/˜lisa/pointeurs/ hierarchical-nnlm-aistats05.pdf. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            640
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Judea Pearl. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann, 1988. ",
+        "bbox": [
+            173,
+            676,
+            821,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stuart Russell and Peter Norvig. Artificial Intelligence: A Modern Approach. Prentice Hall Press, Upper Saddle River, NJ, USA, 3rd edition, 2009. ISBN 0136042597, 9780136042594. ",
+        "bbox": [
+            173,
+            743,
+            823,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David L. Wheeler, Tanya Barrett, Dennis A. Benson, Stephen H. Bryant, Kathi Canese, Vyacheslav Chetvernin, Deanna M. Church, Michael DiCuccio, Ron Edgar, Scott Federhen, Lewis Y. Geer, Yuri Kapustin, Oleg Khovayko, David Landsman, David J. Lipman, Thomas L. Madden, Donna R. Maglott, James Ostell, Vadim Miller, Kim D. Pruitt, Gregory D. Schuler, Edwin Sequeira, Steven T. Sherry, Karl Sirotkin, Alexandre Souvorov, Grigory Starchenko, Roman L. Tatusov, Tatiana A. Tatusova, Lukas Wagner, and Eugene Yaschenko. Database resources of the national center for biotechnology information. Nucleic Acids Research, 35:D5–D12, 2007. doi: 10.1093/nar/gkl1031. URL http://dx.doi.org/10.1093/nar/gkl1031. ",
+        "bbox": [
+            176,
+            809,
+            825,
+            921
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 HYPERPARAMETER GRID AND BEST HYPERPARAMETERS ",
+        "bbox": [
+            174,
+            132,
+            617,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e97ceefaa973eb80cea2b633b933172a46a11d586c09d671f819ce9b080d0ce.jpg",
+        "table_caption": [
+            "Table 2: Hyperparameter space explored for small disease prediction "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter Name</td><td>ValuesExplored</td></tr><tr><td>Learning Rate</td><td>[10-²,10-3,10-4,10-5,10-6]</td></tr><tr><td>Embedding Size</td><td>[64,128,256, 512]</td></tr><tr><td>Number Of Additional Layers</td><td>[0, 1, 2]</td></tr><tr><td>Additional Layer Size</td><td>[128,256, 512]</td></tr><tr><td>Activation function</td><td>[identity, ReLU]</td></tr><tr><td>Shared Weights</td><td>[False,True]</td></tr></table>",
+        "bbox": [
+            271,
+            191,
+            725,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/8b2e89d51ef7417d23a1d307aafdc75d0432a51a166467443916fa86a955da97.jpg",
+        "table_caption": [
+            "Table 3: Best hyperparameters for small disease prediction "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter Name</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>Learning Rate</td><td>10-5</td><td>10-4</td></tr><tr><td>Embedding Size</td><td>512</td><td>256</td></tr><tr><td>Number Of Additional Layers</td><td>0</td><td>0</td></tr><tr><td>Layer Size</td><td>N/A</td><td>N/A</td></tr><tr><td>Activation function</td><td>identity</td><td>identity</td></tr><tr><td>Shared Weights</td><td>True</td><td>True</td></tr></table>",
+        "bbox": [
+            227,
+            385,
+            772,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/3a1d459e5d62c2f36ba8923a2b65f4ac72aa5c73d6a7507c2dd6333930ad6b9f.jpg",
+        "table_caption": [
+            "Table 4: Hyperparameter space explored for large disease prediction "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter Name</td><td>Values Explored</td></tr><tr><td>Learning Rate</td><td>[10-3,10-4,10-5]</td></tr><tr><td>Embedding Size</td><td>[256, 512]</td></tr><tr><td>Number Of Additional Layers</td><td>[0,1,2]</td></tr><tr><td>Additional Layer Size</td><td>[128,256,512]</td></tr><tr><td>Activation function</td><td>[identity,ReLU]</td></tr><tr><td>Shared Weights</td><td>[False, True]</td></tr></table>",
+        "bbox": [
+            312,
+            579,
+            684,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/b978a947f98119e8b154b2ff83f32f7c46c8ad41063863e47365ae4de9227279.jpg",
+        "table_caption": [
+            "Table 5: Best hyperparameters for large disease prediction "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter Name</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>Learning Rate</td><td>10-4</td><td>10-4</td></tr><tr><td>Embedding Size</td><td>512</td><td>512</td></tr><tr><td>Number Of Additional Layers</td><td>0</td><td>0</td></tr><tr><td>Layer Size</td><td>N/A</td><td>N/A</td></tr><tr><td>Activation function</td><td>ReLU</td><td>identity</td></tr><tr><td>Shared Weights</td><td>True</td><td>True</td></tr></table>",
+        "bbox": [
+            227,
+            771,
+            771,
+            910
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/190e600109c05b844cb983a64060f749cc4ffc920c598462bbc2d6f5c4df1705.jpg",
+        "table_caption": [
+            "Table 6: Hyperparameter space explored for protein function prediction "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Learning Rate Hyperparameter Name</td><td>[10-1,10-²,10-3,10-4,10-5] Values Explored</td></tr><tr><td>Embedding Size</td><td>[64,128,256]</td></tr><tr><td>Middle Layer Size</td><td>[128, 256, 512]</td></tr><tr><td>Keep Probability</td><td>[0.5, 0.7, 0.8, 0.9, 1.0]</td></tr></table>",
+        "bbox": [
+            294,
+            131,
+            702,
+            228
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/4b7ac2c39c94030e4463ed3d3c1b20ae2adb6c81a237e9bbd8f7a28fe4c0f1b3.jpg",
+        "table_caption": [
+            "Table 7: Best hyperparameters for protein function prediction "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter Name</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>Learning Rate</td><td>10-3</td><td>10-3</td></tr><tr><td>Embedding Size</td><td>64</td><td>128</td></tr><tr><td>Middle Layer Size</td><td>512</td><td>512</td></tr><tr><td>Keep Probability</td><td>0.7</td><td>0.7</td></tr></table>",
+        "bbox": [
+            250,
+            279,
+            748,
+            377
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/8b80234243434c6e4666f89e691dfce1b1fd3ebc58ea69a41bc05a0eeb2e4cd0.jpg",
+        "table_caption": [
+            "A.2 BINNED PER-LABEL PERFORMANCE NUMBERS FOR LESS FREQUENT LABELS ",
+            "Table 8: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the small disease prediction task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Number of Positive Examples</td><td colspan=\"3\">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.66 (0.65-0.66)</td><td>0.68 (0.68-0.68)</td><td>0.77 (0.77-0.77)</td></tr><tr><td>5-10</td><td>0.66 (0.65-0.66)</td><td>0.68 (0.68-0.68)</td><td>0.77 (0.77-0.77)</td></tr><tr><td>11-25</td><td>0.74 (0.74-0.74)</td><td>0.70 (0.70-0.70)</td><td>0.79 (0.79-0.80)</td></tr><tr><td>26-50</td><td>0.78 (0.78-0.79)</td><td>0.72 (0.72-0.72)</td><td>0.81 (0.80-0.81)</td></tr><tr><td>51-100</td><td>0.80 (0.79-0.80)</td><td>0.74 (0.74-0.74)</td><td>0.81 (0.80-0.81)</td></tr><tr><td>101-250</td><td>0.81 (0.81-0.81)</td><td>0.76 (0.76-0.76)</td><td>0.81 (0.81-0.81)</td></tr><tr><td>251-500</td><td>0.82 (0.82-0.82)</td><td>0.77 (0.77-0.77)</td><td>0.81 (0.80-0.81)</td></tr><tr><td>501-1000</td><td>0.83 (0.83-0.83)</td><td>0.80 (0.79-0.80)</td><td>0.82 (0.82-0.82)</td></tr></table>",
+        "bbox": [
+            176,
+            483,
+            821,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/42c22967e08454252b7cb555cf5e9a43946e64f41e780a19594c0d1f68a3df94.jpg",
+        "table_caption": [
+            "Table 9: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the small disease prediction task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Number of Positive Examples</td><td colspan=\"3\">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.09 (0.08-0.09)</td><td>0.06 (0.06-0.07)</td><td>0.23 (0.22-0.23)</td></tr><tr><td>11-25</td><td>0.11 (0.10-0.11)</td><td>0.04 (0.04-0.04)</td><td>0.19 (0.19-0.19)</td></tr><tr><td>26-50</td><td>0.10 (0.10-0.11)</td><td>0.04 (0.04-0.04)</td><td>0.15 (0.15-0.15)</td></tr><tr><td>51-100</td><td>0.08 (0.08-0.09)</td><td>0.04 (0.04-0.04)</td><td>0.12 (0.11-0.12)</td></tr><tr><td>101-250</td><td>0.08 (0.08-0.08)</td><td>0.05 (0.04-0.05)</td><td>0.10 (0.09-0.10)</td></tr><tr><td>251-500</td><td>0.08 (0.08-0.08)</td><td>0.06 (0.06-0.06)</td><td>0.09 (0.09-0.09)</td></tr><tr><td>501-1000</td><td>0.10 (0.10-0.10)</td><td>0.09 (0.09-0.09)</td><td>0.11 (0.11-0.11)</td></tr></table>",
+        "bbox": [
+            176,
+            162,
+            821,
+            345
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/424c1ecfb255db3730f86f9760ae39802a0de2d91efdee8375b36c513d5823fe.jpg",
+        "table_caption": [
+            "Table 10: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the large disease prediction task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Number of Positive Examples</td><td colspan=\"3\">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.45 (0.42-0.48)</td><td>0.69 (0.66-0.72)</td><td>0.71 (0.68-0.73)</td></tr><tr><td>11-25</td><td>0.50 (0.48-0.51)</td><td>0.75 (0.74-0.77)</td><td>0.76 (0.74-0.78)</td></tr><tr><td>26-50</td><td>0.67 (0.65-0.68)</td><td>0.79 (0.77-0.80)</td><td>0.79 (0.77-0.80)</td></tr><tr><td>51-100</td><td>0.76 (0.76-0.77)</td><td>0.80 (0.80-0.81)</td><td>0.81 (0.80-0.82)</td></tr><tr><td>101-250</td><td>0.81 (0.81-0.82)</td><td>0.82 (0.82-0.83)</td><td>0.82 (0.82-0.82)</td></tr><tr><td>251-500</td><td>0.83 (0.82-0.83)</td><td>0.83 (0.83-0.84)</td><td>0.84 (0.83-0.84)</td></tr><tr><td>501-1000</td><td>0.85 (0.85-0.85)</td><td>0.85 (0.85-0.85)</td><td>0.85 (0.85-0.85)</td></tr></table>",
+        "bbox": [
+            176,
+            439,
+            821,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/2cdd58270052f72b181f99d80270be76001ae28a84f97effd37965953950e24f.jpg",
+        "table_caption": [
+            "Table 11: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the large disease prediction task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Number of Positive Examples</td><td colspan=\"3\">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.08 (0.05-0.11)</td><td>0.33 (0.28-0.37)</td><td>0.38 (0.34-0.43)</td></tr><tr><td>11-25</td><td>0.11 (0.10-0.13)</td><td>0.38 (0.36-0.41)</td><td>0.43 (0.40-0.46)</td></tr><tr><td>26-50</td><td>0.25 (0.23-0.27)</td><td>0.42 (0.39-0.44)</td><td>0.45 (0.43-0.47)</td></tr><tr><td>51-100</td><td>0.33 (0.32-0.35)</td><td>0.39 (0.37-0.40)</td><td>0.43 (0.42-0.45)</td></tr><tr><td>101-250</td><td>0.35 (0.34-0.36)</td><td>0.36 (0.35-0.37)</td><td>0.39 (0.38-0.39)</td></tr><tr><td>251-500</td><td>0.31 (0.30-0.32)</td><td>0.32 (0.31-0.33)</td><td>0.35 (0.35-0.36)</td></tr><tr><td>501-1000</td><td>0.29 (0.29-0.30)</td><td>0.29 (0.28-0.29)</td><td>0.32 (0.31-0.32)</td></tr></table>",
+        "bbox": [
+            176,
+            715,
+            821,
+            898
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/28ff1dd8dd63c12803be36dd6eb22beae4a00ea7084c4e015941d9808edff354.jpg",
+        "table_caption": [
+            "Table 12: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Number of Positive Examples</td><td colspan=\"3\">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.62 (0.60-0.63)</td><td>0.73 (0.71-0.75)</td><td>0.80 (0.79-0.82)</td></tr><tr><td>11-25</td><td>0.61 (0.60-0.62)</td><td>0.74 (0.72-0.76)</td><td>0.80 (0.79-0.82)</td></tr><tr><td>26-50</td><td>0.63 (0.61-0.64)</td><td>0.77 (0.75-0.79)</td><td>0.80 (0.78-0.82)</td></tr><tr><td>51-100</td><td>0.63 (0.62-0.65)</td><td>0.78 (0.76-0.79)</td><td>0.81 (0.79-0.82)</td></tr><tr><td>101-250</td><td>0.64 (0.63-0.65)</td><td>0.77 (0.75-0.78)</td><td>0.79 (0.78-0.81)</td></tr><tr><td>251-500</td><td>0.64 (0.63-0.65)</td><td>0.76 (0.75-0.78)</td><td>0.78 (0.77-0.79)</td></tr><tr><td>501-1000</td><td>0.65 (0.64-0.66)</td><td>0.75 (0.74-0.77)</td><td>0.77 (0.76-0.78)</td></tr></table>",
+        "bbox": [
+            176,
+            232,
+            821,
+            415
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/336a5687e0607310d1c468ded2764b77a16c16b436af02ad60af8a6f2d1b1324.jpg",
+        "table_caption": [
+            "Table 13: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Number of Positive Examples</td><td colspan=\"3\">Model</td></tr><tr><td>Simple Baseline</td><td>Flat Sigmoid</td><td>Bayesian Network of Sigmoids</td></tr><tr><td>5-10</td><td>0.19 (0.17-0.22)</td><td>0.16 (0.14-0.18)</td><td>0.23 (0.21-0.26)</td></tr><tr><td>11-25</td><td>0.15 (0.13-0.17)</td><td>0.18 (0.17-0.20)</td><td>0.21 (0.19-0.23)</td></tr><tr><td>26-50</td><td>0.13 (0.11-0.15)</td><td>0.21 (0.18-0.23)</td><td>0.21 (0.19-0.23)</td></tr><tr><td>51-100</td><td>0.12 (0.11-0.14)</td><td>0.21 (0.19-0.23)</td><td>0.20 (0.18-0.22)</td></tr><tr><td>101-250</td><td>0.12 (0.10-0.13)</td><td>0.21 (0.19-0.23)</td><td>0.21 (0.20-0.23)</td></tr><tr><td>251-500</td><td>0.12 (0.11-0.14)</td><td>0.22 (0.20-0.24)</td><td>0.22 (0.20-0.23)</td></tr><tr><td>501-1000</td><td>0.16 (0.15-0.18)</td><td>0.27 (0.25-0.29)</td><td>0.27 (0.25-0.29)</td></tr></table>",
+        "bbox": [
+            176,
+            646,
+            821,
+            829
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 PROTEIN REWEIGHTED FLAT SIGMOID BASELINE BINNED PER-LABEL PERFORMANCENUMBERS FOR LESS FREQUENT LABELS",
+        "bbox": [
+            174,
+            103,
+            820,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/3666900304e51eb7c0821c517ab8c4f26dae17ec5a4a5bfc064cb5ff89f3f22c.jpg",
+        "table_caption": [
+            "Table 14: AUROC results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task with the reweighted flat sigmoid baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Number of Positive Examples</td><td>Reweighted Flat Sigmoid</td></tr><tr><td>5-10</td><td>0.76 (0.74-0.77)</td></tr><tr><td>11-25</td><td>0.76 (0.74-0.78)</td></tr><tr><td>26-50</td><td>0.77 (0.76-0.79)</td></tr><tr><td>51-100</td><td>0.79 (0.77-0.80)</td></tr><tr><td>101-250</td><td>0.78 (0.76-0.79)</td></tr><tr><td>251-500</td><td>0.77 (0.76-0.79)</td></tr><tr><td>501-1000</td><td>0.77 (0.75-0.78)</td></tr></table>",
+        "bbox": [
+            294,
+            193,
+            704,
+            356
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/a81a4b0be6f9a08657a19ca628a1842f6a62deb9b05f468e7fd0371999731076.jpg",
+        "table_caption": [
+            "Table 15: Average precision results for binned per-label performance on labels with at most 1,000 positive examples for the protein function prediction task with the reweighted flat sigmoid baseline. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Number of Positive Examples</td><td>Reweighted Flat Sigmoid</td></tr><tr><td>5-10</td><td>0.14 (0.12-0.16)</td></tr><tr><td>11-25</td><td>0.16 (0.14-0.18)</td></tr><tr><td>26-50</td><td>0.17 (0.17-0.22)</td></tr><tr><td>51-100</td><td>0.22 (0.19-0.23)</td></tr><tr><td>101-250</td><td>0.22 (0.20-0.24)</td></tr><tr><td>251-500</td><td>0.22 (0.21-0.24</td></tr><tr><td>501-1000</td><td>0.27 (0.25-0.29)</td></tr></table>",
+        "bbox": [
+            295,
+            428,
+            704,
+            590
+        ],
+        "page_idx": 14
+    }
+]

parse/train/rJlnOhVYPS/rJlnOhVYPS.md

@@ -0,0 +1,307 @@
+# MUTUAL MEAN-TEACHING: PSEUDO LABEL REFINERY FOR UNSUPERVISED DOMAIN ADAPTATION ON PERSON RE-IDENTIFICATION
+
+Yixiao Ge, Dapeng Chen & Hongsheng Li The Chinese University of Hong Kong {yxge@link,hsli@ee}.cuhk.edu.hk
+
+# ABSTRACT
+
+Person re-identification (re-ID) aims at identifying the same persons’ images across different cameras. However, domain diversities between different datasets pose an evident challenge for adapting the re-ID model trained on one dataset to another one. State-of-the-art unsupervised domain adaptation methods for person re-ID transferred the learned knowledge from the source domain by optimizing with pseudo labels created by clustering algorithms on the target domain. Although they achieved state-of-the-art performances, the inevitable label noise caused by the clustering procedure was ignored. Such noisy pseudo labels substantially hinders the model’s capability on further improving feature representations on the target domain. In order to mitigate the effects of noisy pseudo labels, we propose to softly refine the pseudo labels in the target domain by proposing an unsupervised framework, Mutual Mean-Teaching (MMT), to learn better features from the target domain via off-line refined hard pseudo labels and on-line refined soft pseudo labels in an alternative training manner. In addition, the common practice is to adopt both the classification loss and the triplet loss jointly for achieving optimal performances in person re-ID models. However, conventional triplet loss cannot work with softly refined labels. To solve this problem, a novel soft softmax-triplet loss is proposed to support learning with soft pseudo triplet labels for achieving the optimal domain adaptation performance. The proposed MMT framework achieves considerable improvements of $1 4 . 4 \%$ , $1 8 . 2 \%$ , $1 3 . 4 \%$ and $1 6 . 4 \%$ mAP on Market-to-Duke, Duke-to-Market, Market-to-MSMT and Duke-to-MSMT unsupervised domain adaptation tasks.
+
+# 1 INTRODUCTION
+
+Person re-identification (re-ID) aims at retrieving the same persons’ images from images captured by different cameras. In recent years, person re-ID datasets with increasing numbers of images were proposed to facilitate the research along this direction. All the datasets require time-consuming annotations and are keys for re-ID performance improvements. However, even with such large-scale datasets, for person images from a new camera system, the person re-ID models trained on existing datasets generally show evident performance drops because of the domain gaps. Unsupervised Domain Adaptation (UDA) is therefore proposed to adapt the model trained on the source image domain (dataset) with identity labels to the target image domain (dataset) with no identity annotations.
+
+State-of-the-art UDA methods (Song et al., 2018; Zhang et al., 2019b; Yang et al., 2019) for person re-ID group unannotated images with clustering algorithms and train the network with clusteringgenerated pseudo labels. Although the pseudo label generation and feature learning with pseudo labels are conducted alternatively to refine the pseudo labels to some extent, the training of the neural network is still substantially hindered by the inevitable label noise. The noise derives from the limited transferability of source-domain features, the unknown number of target-domain identities, and the imperfect results of the clustering algorithm. The refinery of noisy pseudo labels has crucial influences to the final performance, but is mostly ignored by the clustering-based UDA methods.
+
+![](images/deb1c3dd38d064407320654735af3057968f15eb6bd510f2e4998739458e73f2.jpg)  
+Figure 1: Person image $A _ { 1 }$ and $A _ { 2 }$ belong to the same identity while $B$ with similar appearance is from another person. However, clustering-generated pseudo labels in state-of-the-art Unsupervised Domain Adaptation (UDA) methods contain much noise that hinders feature learning. We propose pseudo label refinery with on-line refined soft pseudo labels to effectively mitigate the influence of noisy pseudo labels and improve UDA performance on person re-ID.
+
+To effectively address the problem of noisy pseudo labels in clustering-based UDA methods (Song et al., 2018; Zhang et al., 2019b; Yang et al., 2019) (Figure 1), we propose an unsupervised Mutual Mean-Teaching (MMT) framework to effectively perform pseudo label refinery by optimizing the neural networks under the joint supervisions of off-line refined hard pseudo labels and on-line refined soft pseudo labels. Specifically, our proposed MMT framework provides robust soft pseudo labels in an on-line peer-teaching manner, which is inspired by the teacher-student approaches (Tarvainen & Valpola, 2017; Zhang et al., 2018b) to simultaneously train two same networks. The networks gradually capture target-domain data distributions and thus refine pseudo labels for better feature learning. To avoid training error amplification, the temporally average model of each network is proposed to produce reliable soft labels for supervising the other network in a collaborative training strategy. By training peer-networks with such on-line soft pseudo labels on the target domain, the learned feature representations can be iteratively improved to provide more accurate soft pseudo labels, which, in turn, further improves the discriminativeness of learned feature representations.
+
+The classification and triplet losses are commonly adopted together to achieve state-of-the-art performances in both fully-supervised (Luo et al., 2019) and unsupervised (Zhang et al., 2019b; Yang et al., 2019) person re-ID models. However, the conventional triplet loss (Hermans et al., 2017) cannot work with such refined soft labels. To enable using the triplet loss with soft pseudo labels in our MMT framework, we propose a novel soft softmax-triplet loss so that the network can benefit from softly refined triplet labels. The introduction of such soft softmax-triplet loss is also the key to the superior performance of our proposed framework. Note that the collaborative training strategy on the two networks is only adopted in the training process. Only one network is kept in the inference stage without requiring any additional computational or memory cost.
+
+The contributions of this paper could be summarized as three-fold. (1) We propose to tackle the label noise problem in state-of-the-art clustering-based UDA methods for person re-ID, which is mostly ignored by existing methods but is shown to be crucial for achieving superior final performance. The proposed Mutual Mean-Teaching (MMT) framework is designed to provide more reliable soft labels. (2) Conventional triplet loss can only work with hard labels. To enable training with soft triplet labels for mitigating the pseudo label noise, we propose the soft softmax-triplet loss to learn more discriminative person features. (3) The MMT framework shows exceptionally strong performances on all UDA tasks of person re-ID. Compared with state-of-the-art methods, it leads to significant improvements of $1 4 . 4 \%$ , $1 8 . 2 \%$ , $1 3 . 4 \%$ , $1 6 . 4 \%$ mAP on Market-to-Duke, Duke-to-Market, Market-to-MSMT, Duke-to-MSMT re-ID tasks.
+
+# 2 RELATED WORK
+
+Unsupervised domain adaptation (UDA) for person re-ID. UDA methods have attracted much attention because their capability of saving the cost of manual annotations. There are three main categories of methods. The first category of clustering-based methods maintains state-of-the-art performance to date. (Fan et al., 2018) proposed to alternatively assign labels for unlabeled training samples and optimize the network with the generated targets. (Lin et al., 2019) proposed a bottomup clustering framework with a repelled loss. (Yang et al., 2019) introduced to assign hard pseudo labels for both global and local features. However, the training of the neural network was substantially hindered by the noise of the hard pseudo labels generated by clustering algorithms, which was mostly ignored by existing methods. The second category of methods learns domain-invariant features from style-transferred source-domain images. SPGAN (Deng et al., 2018) and PTGAN (Wei et al., 2018) transformed source-domain images to match the image styles of the target domain while maintaining the original person identities. The style-transferred images and their identity labels were then used to fine-tune the model. HHL (Zhong et al., 2018) learned camera-invariant features with camera style transferred images. However, the retrieval performances of these methods deeply relied on the image generation quality, and they did not explore the complex relations between different samples in the target domain. The third category of methods attempts on optimizing the neural networks with soft labels for target-domain samples by computing the similarities with reference images or features. ENC (Zhong et al., 2019) assigned soft labels by saving averaged features with an exemplar memory module. MAR (Yu et al., 2019) conducted multiple soft-label learning by comparing with a set of reference persons. However, the reference images and features might not be representative enough to generate accurate labels for achieving advanced performances.
+
+Generic domain adaptation methods for close-set recognition. Generic domain adaptation methods learn features that can minimize the differences between data distributions of source and target domains. Adversarial learning based methods (Zhang et al., 2018a; Tzeng et al., 2017; Ghifary et al., 2016; Bousmalis et al., 2016; Tzeng et al., 2015) adopted a domain classifier to dispel the discriminative domain information from the learned features in order to reduce the domain gap. There also exist methods (Tzeng et al., 2014; Long et al., 2015; Yan et al., 2017; Saito et al., 2018; Ghifary et al., 2016) that minimize the Maximum Mean Discrepancy (MMD) loss between source- and target-domain distributions. However, these methods assume that the classes on different domains are shared, which is not suitable for unsupervised domain adaptation on person re-ID.
+
+Teacher-student models have been widely studied in semi-supervised learning methods and knowledge/model distillation methods. The key idea of teacher-student models is to create consistent training supervisions for labeled/unlabeled data via different models’ predictions. Temporal ensembling (Laine & Aila, 2016) maintained an exponential moving average prediction for each sample as the supervisions of the unlabeled samples, while the mean-teacher model (Tarvainen & Valpola, 2017) averaged model weights at different training iterations to create the supervisions for unlabeled samples. Deep mutual learning (Zhang et al., 2018b) adopted a pool of student models instead of the teacher models by training them with supervisions from each other. However, existing methods with teacher-student mechanisms are mostly designed for close-set recognition problems, where both labeled and unlabeled data share the same set of class labels and could not be directly utilized on unsupervised domain adaptation tasks of person re-ID.
+
+Generic methods for handling noisy labels can be classified into four categories. Loss correction methods (Patrini et al., 2017; Vahdat, 2017; Xiao et al., 2015) tried to model the noise transition matrix, however, such matrix is hard to estimate in real-world tasks, e.g. unsupervised person re-ID with noisy pseudo labels obtained via clustering algorithm. (Veit et al., 2017; Lee et al., 2018; Li et al., 2017; Han et al., 2019) attempted to correct the noisy labels directly, while the clean set required by such methods limits their generalization on real-world applications. Noise-robust methods designed robust loss functions against label noises, for instance, Mean Absolute Error (MAE) loss (Ghosh et al., 2017), Generalized Cross Entropy (GCE) loss (Zhang & Sabuncu, 2018) and Label Smoothing Regularization (LSR) (Szegedy et al., 2016). However, these methods did not study how to handle the triplet loss with noisy labels, which is crucial for learning discriminative feature representations on person re-ID. The last kind of methods which focused on refining the training strategies is mostly related to our method. Co-teaching (Han et al., 2018) trained two collaborative networks and conducted noisy label detection by selecting on-line clean data for each other, Co-mining (Wang et al., 2019) further extended this method on the face recognition task with a re-weighting function for Arc-Softmax loss (Deng et al., 2019). However, the above methods are not designed for the open-set person re-ID task and could not achieve state-of-the-art performances under the more challenge unsupervised settings.
+
+# 3 PROPOSED APPROACH
+
+We propose a novel Mutual Mean-Teaching (MMT) framework for tackling the problem of noisy pseudo labels in clustering-based Unsupervised Domain Adaptation (UDA) methods. The label noise has important impacts to the domain adaptation performance but was mostly ignored by those methods. Our key idea is to conduct pseudo label refinery in the target domain by optimizing the neural networks with off-line refined hard pseudo labels and on-line refined soft pseudo labels in a collaborative training manner. In addition, the conventional triplet loss cannot properly work with soft labels. A novel soft softmax-triplet loss is therefore introduced to better utilize the softly refined pseudo labels. Both the soft classification loss and the soft softmax-triplet loss work jointly to achieve optimal domain adaptation performances.
+
+Formally, we denote the source domain data as $\mathbb { D } _ { s } = \{ ( \pmb { x } _ { i } ^ { s } , \pmb { y } _ { i } ^ { s } ) | _ { i = 1 } ^ { N _ { s } } \}$ , where $\pmb { x } _ { i } ^ { s }$ and $\pmb { y } _ { i } ^ { s }$ denote the -th training sample and its associated person identity label, $N _ { s }$ is the number of images, and $M _ { s }$ denotes the number of person identities (classes) in the source domain. The $N _ { t }$ target-domain images are denoted as $\mathbb { D } _ { t } = \{ \mathbf { x } _ { i } ^ { t } | _ { i = 1 } ^ { N _ { t } } \}$ , which are not associated with any ground-truth identity label.
+
+# 3.1 CLUSTERING-BASED UDA METHODS REVISIT
+
+State-of-the-art UDA methods (Fan et al., 2018; Lin et al., 2019; Zhang et al., 2019b; Yang et al., 2019) follow a similar general pipeline. They generally pre-train a deep neural network $F ( \cdot | \pmb \theta )$ on the source domain, where $\mathbf { \bar { \theta } }$ denotes current network parameters, and the network is then transferred to learn from the images in the target domain. The sfeatures encoded by the network are denoted as $\{ F ( \pmb { x } _ { i } ^ { s } | \pmb { \theta } ) \} | _ { i = 1 } ^ { N _ { s } }$ mageand $\underset { . . } { \{ F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } ) \} } | _ { i = 1 } ^ { N _ { t } }$ main images’respectively. As illustrated in Figure 2 (a), two operations are alternated to gradually fine-tune the pre-trained network on the target domain. (1) The target-domain samples are grouped into pre-defined $M _ { t }$ classes by clustering the features $\{ F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } ) \} | _ { i = 1 } ^ { N _ { t } }$ output by the current network. Let $\tilde { y } _ { i } ^ { t }$ denotes the pseudo label generated for image $\boldsymbol { x } _ { i } ^ { t }$ . (2) The network parameters $\pmb { \theta }$ and a learnable target-domain classifier $C ^ { t } : { \bf f } ^ { t }  \{ 1 , \cdots , M _ { t } \}$ are then optimized with respect to an identity classification (crossentropy) loss $\mathcal { L } _ { i d } ^ { t } ( \pmb { \theta } )$ and a triplet loss (Hermans et al., 2017) $\mathcal { L } _ { t r i } ^ { t } ( \pmb { \theta } )$ in the form of,
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { i d } ^ { t } ( \pmb { \theta } ) = \displaystyle \frac { 1 } { N _ { t } } \sum _ { i = 1 } ^ { N _ { t } } \mathcal { L } _ { c e } \left( C ^ { t } ( F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } ) ) , \tilde { \pmb { y } } _ { i } ^ { t } \right) , } \\ & { \mathcal { L } _ { t r i } ^ { t } ( \pmb { \theta } ) = \displaystyle \frac { 1 } { N _ { t } } \sum _ { i = 1 } ^ { N _ { t } } \operatorname* { m a x } \left( 0 , \| F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } ) - F ( \pmb { x } _ { i , p } ^ { t } | \pmb { \theta } ) \| + m - \| F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } ) - F ( \pmb { x } _ { i , n } ^ { t } | \pmb { \theta } ) \| \right) , } \end{array}
+$$
+
+where $| | \cdot | |$ denotes the $L ^ { 2 }$ -norm distance, subscripts ${ } _ { i , p }$ and $^ { i , n }$ indicate the hardest positive and hardest negative feature index in each mini-batch for the sample $\boldsymbol { x } _ { i } ^ { t }$ , and $m = 0 . 5$ denotes the triplet distance margin. Such two operations, pseudo label generation by clustering and feature learning with pseudo labels, are alternated until the training converges. However, the pseudo labels generated in step (1) inevitably contain errors due to the imperfection of features as well as the errors of the clustering algorithms, which hinder the feature learning in step (2). To mitigate the pseudo label noise, we propose the Mutual Mean-Teaching (MMT) framework together with a novel soft softmax-triplet loss to conduct the pseudo label refinery.
+
+# 3.2 MUTUAL MEAN-TEACHING (MMT) FRAMEWORK
+
+# 3.2.1 SUPERVISED PRE-TRAINING FOR SOURCE DOMAIN
+
+UDA task on person re-ID aims at transferring the knowledge from a pre-trained model on the source domain to the target domain. A deep neural network is first pre-trained on the source domain. Given the training data $\mathbf { \bar { \mathbb { D } } } _ { s }$ , the network is trained to model a feature transformation function $F ( \cdot | \theta )$ that transforms each input sample $\mathbf { \boldsymbol { x } } _ { i } ^ { s }$ into a feature representation $F ( \pmb { x } _ { i } ^ { s } | \pmb { \theta } )$ . Given the encoded features, the identification classifier $C ^ { s }$ outputs an $M _ { s }$ -dimensional probability vector to predict the identities in the source-domain training set. The neural network is trained with a classification loss $\mathcal { L } _ { i d } ^ { s } ( \pmb { \theta } )$ and a triplet loss $\mathcal { L } _ { t r i } ^ { s } ( \pmb { \theta } )$ to separate features belonging to different identities. The overall loss is therefore calculated as
+
+$$
+\begin{array} { r } { \begin{array} { r } { \mathcal { L } ^ { s } ( \pmb { \theta } ) = \mathcal { L } _ { i d } ^ { s } ( \pmb { \theta } ) + \lambda ^ { s } \mathcal { L } _ { t r i } ^ { s } ( \pmb { \theta } ) , } \end{array} } \end{array}
+$$
+
+where $\mathcal { L } _ { i d } ^ { s } ( \pmb { \theta } )$ and $\mathcal { L } _ { t r i } ^ { s } ( \pmb { \theta } )$ are defined similarly to equation 1 and equation 2 but with ground-truth identity labels $\{ y _ { i } ^ { s } | _ { i = 1 } ^ { N _ { s } } \}$ , and $\lambda ^ { s }$ is the parameter weighting the two losses.
+
+![](images/544fa933ae039aeed3f7a3fd88bef1e6d3f72fe910b0beb1204cf298d0fdb425.jpg)  
+Figure 2: (a) The pipeline for existing clustering-based UDA methods on person re-ID with noisy hard pseudo labels. (b) Overall framework of the proposed Mutual Mean-Teaching (MMT) with two collaborative networks jointly optimized under the supervisions of off-line refined hard pseudo labels and on-line refined soft pseudo labels. A soft identity classification loss and a novel soft softmax-triplet loss are adopted. (c) One of the average models with better validated performance is adopted for inference as average models perform better than models with current parameters.
+
+# 3.2.2 PSEUDO LABEL REFINERY WITH ON-LINE REFINED SOFT PSEUDO LABELS
+
+Our proposed MMT framework is based on the clustering-based UDA methods with off-line refined hard pseudo labels as introduced in Section 3.1, where the pseudo label generation and refinement are conducted alternatively. However, the pseudo labels generated in this way are hard (i.e., they are always of $1 0 0 \%$ confidences) but noisy. In order to mitigate the pseudo label noise, apart from the off-line refined hard pseudo labels, our framework further incorporates on-line refined soft pseudo labels (i.e., pseudo labels with $< 1 0 0 \%$ confidences) into the training process.
+
+Our MMT framework generates soft pseudo labels by collaboratively training two same networks with different initializations. The overall framework is illustrated in Figure 2 (b). The pseudo classes are still generated the same as those by existing clustering-based UDA methods, where each cluster represents one class. In addition to the hard and noisy pseudo labels, our two collaborative networks also generate on-line soft pseudo labels by network predictions for training each other. The intuition is that, after the networks are trained even with hard pseudo labels, they can roughly capture the training data distribution and their class predictions can therefore serve as soft class labels for training. However, such soft labels are generally not perfect because of the training errors and noisy hard pseudo labels in the first place. To avoid two networks collaboratively bias each other, the past temporally average model of each network instead of the current model is used to generate the soft pseudo labels for the other network. Both off-line hard pseudo labels and on-line soft pseudo labels are utilized jointly to train the two collaborative networks. After training, only one of the past average models with better validated performance is adopted for inference (see Figure 2 (c)).
+
+We denote the two collaborative networks as feature transformation functions $F ( \cdot | \pmb \theta _ { 1 } )$ and $F ( \cdot | \pmb { \theta } _ { 2 } )$ , and denote their corresponding pseudo label classifiers as $C _ { 1 } ^ { t }$ and $C _ { 2 } ^ { t }$ , respectively. To simultaneously train the coupled networks, we feed the same image batch to the two networks but with separately random erasing, cropping and flipping. Each target-domain image can be denoted by $\boldsymbol { x } _ { i } ^ { t }$ and $\boldsymbol { x ^ { \prime } } _ { i } ^ { t }$ for the two networks, and their pseudo label confidences can be predicted as $C _ { 1 } ^ { t } ( F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } _ { 1 } ) )$ and $C _ { 2 } ^ { t } ( F ( { \pmb x } ^ { \prime } { } _ { i } ^ { t } | \pmb \theta _ { 2 } ) )$ . One na¨ıve way to train the collaborative networks is to directly utilize the above pseudo label confidence vectors as the soft pseudo labels for training the other network. However, in such a way, the two networks’ predictions might converge to equal each other and the two networks lose their output independences. The classification errors as well as pseudo label errors might be amplified during training. In order to avoid error amplification, we propose to use the temporally average model of each network to generate reliable soft pseudo labels for supervising the other network. Specifically, the parameters of the temporally average models of the two networks at current iteration $T$ are denoted as $E ^ { ( T ) } [ \pmb { \theta } _ { 1 } ]$ and $E ^ { ( T ) } [ \pmb { \theta } _ { 2 } ]$ respectively, which can be calculated as
+
+$$
+\begin{array} { r } { E ^ { ( T ) } [ \pmb { \theta } _ { 1 } ] = \alpha E ^ { ( T - 1 ) } [ \pmb { \theta } _ { 1 } ] + ( 1 - \alpha ) \pmb { \theta } _ { 1 } , } \\ { E ^ { ( T ) } [ \pmb { \theta } _ { 2 } ] = \alpha E ^ { ( T - 1 ) } [ \pmb { \theta } _ { 2 } ] + ( 1 - \alpha ) \pmb { \theta } _ { 2 } , } \end{array}
+$$
+
+where $E ^ { ( T - 1 ) } [ \pmb { \theta } _ { 1 } ]$ , $E ^ { ( T - 1 ) } [ \pmb { \theta } _ { 2 } ]$ indicate the temporal average parameters of the two networks in the previous iteration $( T - 1 )$ , the initial temporal average parameters are ${ \cal E } ^ { ( 0 ) } [ \pmb { \theta } _ { 1 } ] = \pmb { \theta } _ { 1 } , { \cal E } ^ { ( 0 ) } [ \pmb { \theta } _ { 2 } ] = \pmb { \theta } _ { 2 }$ , and $\alpha$ is the ensembling momentum to be within the range $[ 0 , 1 )$ . The robust soft pseudo label supervisions are then generated by the two temporal average models as $C _ { 1 } ^ { t } ( F ( \pmb { x } _ { i } ^ { t } | E ^ { ( T ) } [ \pmb { \theta } _ { 1 } ] ) )$ and $C _ { 2 } ^ { t } ( F ( { \pmb x ^ { \prime } } _ { i } ^ { t } | E ^ { ( T ) } [ \pmb \theta _ { 2 } ] ) )$ respectively. The soft classification loss for optimizing $\pmb { \theta } _ { 1 }$ and $\pmb { \theta } _ { 2 }$ with the soft pseudo labels generated from the other network can therefore be formulated as
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { s i d } ^ { t } ( \pmb { \theta } _ { 1 } | \pmb { \theta _ { 2 } } ) = - \cfrac { 1 } { N _ { t } } \displaystyle \sum _ { i = 1 } ^ { N _ { t } } \bigg ( C _ { 2 } ^ { t } \big ( F \big ( \pmb { x } ^ { \prime } _ { i } | \boldsymbol { E } ^ { ( T ) } [ \pmb { \theta _ { 2 } } ] \big ) \big ) \cdot \log C _ { 1 } ^ { t } \big ( F \big ( \pmb { x } _ { i } ^ { t } | \pmb { \theta _ { 1 } } ) \big ) \bigg ) , } \\ & { \mathcal { L } _ { s i d } ^ { t } ( \pmb { \theta _ { 2 } } | \pmb { \theta _ { 1 } } ) = - \cfrac { 1 } { N _ { t } } \displaystyle \sum _ { i = 1 } ^ { N _ { t } } \bigg ( C _ { 1 } ^ { t } \big ( F \big ( \pmb { x } _ { i } ^ { t } | \boldsymbol { E } ^ { ( T ) } [ \pmb { \theta _ { 1 } } ] \big ) \big ) \cdot \log C _ { 2 } ^ { t } \big ( F \big ( \pmb { x } ^ { \prime } _ { i } ^ { t } | \pmb { \theta _ { 2 } } ) \big ) \bigg ) . } \end{array}
+$$
+
+The two networks’ pseudo-label predictions are better dis-related by using other network’s past average model to generate supervisions and can therefore better avoid error amplification.
+
+Generalizing classification cross-entropy loss to work with soft pseudo labels has been well studied (Hinton et al., 2015), (Muller et al., 2019). However, optimizing triplet loss with soft pseudo labels ¨ poses a great challenge as no previous method has investigated soft labels for triplet loss. For tackling the difficulty, we propose to use softmax-triplet loss, whose hard version is formulated as
+
+$$
+\mathcal { L } _ { t r i } ^ { t } ( \pmb { \theta } _ { 1 } ) = \frac { 1 } { N _ { t } } \sum _ { i = 1 } ^ { N _ { t } } \mathcal { L } _ { b c e } \bigg ( \mathcal { T } _ { i } ( \pmb { \theta } _ { 1 } ) , \mathbf { 1 } \bigg ) ,
+$$
+
+where
+
+$$
+\mathcal { T } _ { i } ( \pmb { \theta } _ { 1 } ) = \frac { \exp ( \| F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } _ { 1 } ) - F ( \pmb { x } _ { i , n } ^ { t } | \pmb { \theta } _ { 1 } ) \| ) } { \exp ( \| F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } _ { 1 } ) - F ( \pmb { x } _ { i , p } ^ { t } | \pmb { \theta } _ { 1 } ) \| ) + \exp ( \| F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } _ { 1 } ) - F ( \pmb { x } _ { i , n } ^ { t } | \pmb { \theta } _ { 1 } ) \| ) } .
+$$
+
+Here $\mathcal { L } _ { b c e } ( \cdot , \cdot )$ denotes the binary cross-entropy loss, $F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } _ { 1 } )$ is the encoded feature for targetdomain sample $\boldsymbol { x } _ { i } ^ { t }$ by network 1, the subscripts ${ } _ { i , p }$ and $^ { i , n }$ denote sample $\boldsymbol { x } _ { i } ^ { t }$ ’s hardest positive and negative samples in the mini-batch, $\| F ( \pmb { x } _ { i } ^ { t } | \pmb { \theta } _ { 1 } ) - F ( \pmb { x } _ { i , p } ^ { t } | \pmb { \theta } _ { 1 } ) \|$ is the $L ^ { 2 }$ -norm distance between sample $\boldsymbol { x } _ { i } ^ { t }$ and its positive sample $\mathit { \mathbf { x } } _ { i , p } ^ { t }$ to measure their similarity, and “1” denotes the ground-truth that the positive sample $\mathit { \mathbf { x } } _ { i , p } ^ { t }$ should be closer to the sample $\boldsymbol { x } _ { i } ^ { t }$ than its negative sample $\boldsymbol { x } _ { i , n } ^ { t }$ . Given the two collaborative networks, we can utilize the one network’s past temporal average model to generate soft triplet labels for the other network with the proposed soft softmax-triplet loss,
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { s t r i } ^ { t } ( \pmb { \theta } _ { 1 } | \pmb { \theta } _ { 2 } ) = \cfrac { 1 } { N _ { t } } \displaystyle \sum _ { i = 1 } ^ { N _ { t } } \mathcal { L } _ { b c e } \bigg ( \mathcal { T } _ { i } ( \pmb { \theta } _ { 1 } ) , \mathcal { T } _ { i } \left( E ^ { ( T ) } [ \pmb { \theta } _ { 2 } ] \right) \bigg ) \bigg ) , } \\ & { \mathcal { L } _ { s t r i } ^ { t } ( \pmb { \theta } _ { 2 } | \pmb { \theta } _ { 1 } ) = \cfrac { 1 } { N _ { t } } \displaystyle \sum _ { i = 1 } ^ { N _ { t } } \mathcal { L } _ { b c e } \bigg ( \mathcal { T } _ { i } ( \pmb { \theta } _ { 2 } ) , \mathcal { T } _ { i } \left( E ^ { ( T ) } [ \pmb { \theta } _ { 1 } ] \right) \bigg ) \bigg ) , } \end{array}
+$$
+
+where $\mathcal { T } _ { i } ( E ^ { ( T ) } [ \pmb { \theta } _ { 1 } ] )$ and $\mathcal { T } _ { i } ( E ^ { ( T ) } [ \pmb { \theta } _ { 2 } ] )$ are the soft triplet labels generated by the two networks’ past temporally average models. Such soft triplet labels are fixed as training supervisions. By adopting the soft softmax-triplet loss, our MMT framework overcomes the limitation of hard supervisions by the conventional triple loss (equation 2). It can be successfully trained with soft triplet labels, which are shown to be important for improving the domain adaptation performance in our experiments. Note that such a softmax-triplet loss was also studied in (Zhang et al., 2019a). However, it has never been used to generate soft labels and was not designed to work with soft pseudo labels before.
+
+# 3.2.3 OVERALL LOSS AND ALGORITHM
+
+Our proposed MMT framework is trained with both off-line refined hard pseudo labels and on-line refined soft pseudo labels. The overall loss function $\mathcal { L } ( \theta _ { 1 } , \theta _ { 2 } )$ simultaneously optimizes the coupled networks, which combines equation 1, equation 5, equation 6, equation 8 and is formulated as,
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \pmb { \theta } _ { 1 } , \pmb { \theta } _ { 2 } ) = ( 1 - \lambda _ { i d } ^ { t } ) ( \mathcal { L } _ { i d } ^ { t } ( \pmb { \theta } _ { 1 } ) + \mathcal { L } _ { i d } ^ { t } ( \pmb { \theta } _ { 2 } ) ) + \lambda _ { i d } ^ { t } ( \mathcal { L } _ { s i d } ^ { t } ( \pmb { \theta } _ { 1 } | \pmb { \theta } _ { 2 } ) + \mathcal { L } _ { s i d } ^ { t } ( \pmb { \theta } _ { 2 } | \pmb { \theta } _ { 1 } ) ) } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad + ( 1 - \lambda _ { t r i } ^ { t } ) ( \mathcal { L } _ { t r i } ^ { t } ( \pmb { \theta } _ { 1 } ) + \mathcal { L } _ { t r i } ^ { t } ( \pmb { \theta } _ { 2 } ) ) + \lambda _ { t r i } ^ { t } ( \mathcal { L } _ { s t r i } ^ { t } ( \pmb { \theta } _ { 1 } | \pmb { \theta } _ { 2 } ) + \mathcal { L } _ { s t r i } ^ { t } ( \pmb { \theta } _ { 2 } | \pmb { \theta } _ { 1 } ) ) , } \end{array}
+$$
+
+where $\lambda _ { i d } ^ { t }$ , $\lambda _ { t r i } ^ { t }$ are the weighting parameters. The detailed optimization procedures are summarized in Algorithm 1. The hard pseudo labels are off-line refined after training with existing hard pseudo labels for one epoch. During the training process, the two networks are trained by combining the offline refined hard pseudo labels and on-line refined soft labels predicted by their peers with proposed soft losses. The noise and randomness caused by hard clustering, which lead to unstable training and limited final performance, can be alleviated by the proposed MMT framework.
+
+Require: Target-domain data $\mathbb { D } _ { t }$ ;   
+Require: Ensembling momentum $_ \alpha$ for equation 4, weighting factors $\lambda _ { i d } ^ { t }$ , $\lambda _ { t r i } ^ { t }$ for equation 9;   
+Require: Initialize pre-trained weights $\pmb { \theta } _ { 1 }$ and $\pmb { \theta } _ { 2 }$ by optimizing with equation $^ 3$ on $\mathbb { D } _ { s }$ . for n in [1, num epochs] do Generate hard pseudo labels $\tilde { \mathbf { \pmb { y } } } _ { i } ^ { t }$ for each sample $\boldsymbol { \mathscr { x } } _ { i } ^ { t }$ in $\mathbb { D } _ { t }$ by clustering algorithms. for each mini-batch $B \subset \mathbb { D } _ { t }$ , iteration $_ T$ do 1: Generate soft pseudo labels from the collaborative networks by predicting $\mathcal { T } _ { i \in B } \big ( E ^ { ( T ) } [ \pmb { \theta } _ { 1 } ] \big )$ , $\mathcal { T } _ { i \in B } \big ( E ^ { ( T ) } [ \pmb { \theta } _ { 2 } ] \big )$ , $C _ { 1 } ^ { t } ( F ( \pmb { x } _ { i \in B } ^ { t } | E ^ { ( T ) } [ \pmb { \theta } _ { 1 } ] ) )$ ), t $C _ { 2 } ^ { t } ( F ( { \pmb x } ^ { \prime } { } _ { i \in B } ^ { t } | E ^ { ( T ) } [ \pmb \theta _ { 2 } ] ) )$ ;escent of the objective function equation 9; $\pmb { \theta } _ { 1 } \ \& \ \pmb { \theta } _ { 2 }$ 3: Update temporally average model weights $E ^ { ( T + 1 ) } [ \pmb { \theta } _ { 1 } ]$ & $E ^ { ( T + 1 ) } [ \pmb { \theta } _ { 2 } ]$ following equation 4. end for
+
+Algorithm 1: Unsupervised Mutual Mean-Teaching (MMT) Training Strategy
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+We evaluate our proposed MMT on three widely-used person re-ID datasets, i.e., Market1501 (Zheng et al., 2015), DukeMTMC-reID (Ristani et al., 2016), and MSMT17 (Wei et al., 2018). The Market-1501 (Zheng et al., 2015) dataset consists of 32,668 annotated images of 1,501 identities shot from 6 cameras in total, for which 12,936 images of 751 identities are used for training and 19,732 images of 750 identities are in the test set. DukeMTMC-reID (Ristani et al., 2016) contains 16,522 person images of 702 identities for training, and the remaining images out of another 702 identities for testing, where all images are collected from 8 cameras. MSMT17 (Wei et al., 2018) is the most challenging and large-scale dataset consisting of 126,441 bounding boxes of 4,101 identities taken by 15 cameras, for which 32,621 images of 1,041 identities are spitted for training. For evaluating the domain adaptation performance of different methods, four domain adaptation tasks are set up, i.e., Duke-to-Market, Market-to-Duke, Duke-to-MSMT and Market-to-MSMT, where only identity labels on the source domain are provided. Mean average precision (mAP) and CMC top-1, top-5, top-10 accuracies are adopted to evaluate the methods’ performances.
+
+# 4.2 IMPLEMENTATION DETAILS
+
+# 4.2.1 TRAINING DATA ORGANIZATION
+
+For both source-domain pre-training and target-domain fine-tuning, each training mini-batch contains 64 person images of 16 actual or pseudo identities (4 for each identity). Note that the generated hard pseudo labels for the target-domain fine-tuning are updated after each epoch, so the mini-batch of target-domain images needs to be re-organized with updated hard pseudo labels after each epoch. All images are resized to $2 5 6 \times 1 2 8$ before being fed into the networks.
+
+# 4.2.2 OPTIMIZATION DETAILS
+
+All the hyper-parameters of the proposed MMT framework are chosen based on a validation set of the Duke-to-Market task with $M _ { t } = 5 0 0$ pseudo identities and IBN-ResNet-50 backbone. The same hyper-parameters are then directly applied to the other three domain adaptation tasks. We propose a two-stage training scheme, where ADAM optimizer is adopted to optimize the networks with a weight decay of 0.0005. Randomly erasing (Zhong et al., 2017b) is only adopted in target-domain fine-tuning.
+
+Stage 1: Source-domain pre-training. We adopt ResNet-50 (He et al., 2016) or IBN-ResNet-50 (Pan et al., 2018) as the backbone networks, where IBN-ResNet-50 achieves better performances by integrating both IN and BN modules. Two same networks are initialized with ImageNet (Deng et al., 2009) pre-trained weights. Given the mini-batch of images, network parameters $\pmb { \theta } _ { 1 }$ , $\pmb { \theta } _ { 2 }$ are updated independently by optimizing equation 3 with $\lambda ^ { s } = 1$ . The initial learning rate is set to 0.00035 and is decreased to $1 / 1 0$ of its previous value on the 40th and 70th epoch in the total 80 epochs.
+
+Stage 2: End-to-end training with MMT. Based on pre-trained weights $\pmb { \theta } _ { 1 }$ and $\pmb { \theta } _ { 2 }$ , the two networks are collaboratively updated by optimizing equation 9 with the loss weights $\lambda _ { i d } ^ { t } = 0 . 5$ , $\lambda _ { t r i } ^ { t } = 0 . 8$ . The temporal ensemble momentum $\alpha$ in equation 4 is set to 0.999. The learning rate is fixed to 0.00035 for overall 40 training epochs. We utilize $k$ -means clustering algorithm and the number $M _ { t }$ of pseudo classes is set as 500, 700, 900 for Market-1501 and DukeMTMC-reID, and 500, 1000, 1500, 2000 for MSMT17. Note that actual identity numbers in the target-domain training sets are different from $M _ { t }$ . We test different $M _ { t }$ values that are either smaller or greater than actual numbers.
+
+Table 1: Experimental results of the proposed MMT and state-of-the-art methods on Market1501 (Zheng et al., 2015), DukeMTMC-reID (Ristani et al., 2016), and MSMT17 (Wei et al., 2018) datasets, where MMT- $M _ { t }$ represents the result with $M _ { t }$ pseudo classes. Note that none of $M _ { t }$ values equals the actual number of identities but our method still outperforms all state-of-the-arts.   
+
+<table><tr><td rowspan="2">Methods</td><td colspan="4">Market-to-Duke</td><td colspan="4">Duke-to-Market</td></tr><tr><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td></tr><tr><td>PUL (Fan et al.,2018) (TOMM&#x27;18)</td><td>16.4</td><td>30.0</td><td>43.4</td><td>48.5</td><td>20.5</td><td>45.5</td><td>60.7</td><td>66.7</td></tr><tr><td>TJ-AIDL (Wang et al.,2018) (CVPR&#x27;18)</td><td>23.0</td><td>44.3</td><td>59.6</td><td>65.0</td><td>26.5</td><td>58.2</td><td>74.8</td><td>81.1</td></tr><tr><td>SPGAN (Deng et al.,2018)(CVPR&#x27;18)</td><td>22.3</td><td>41.1</td><td>56.6</td><td>63.0</td><td>22.8</td><td>51.5</td><td>70.1</td><td>76.8</td></tr><tr><td>HHL (Zhong et al.,2018)(ECCV&#x27;18)</td><td>27.2</td><td>46.9</td><td>61.0</td><td>66.7</td><td>31.4</td><td>62.2</td><td>78.8</td><td>84.0</td></tr><tr><td>CFSM(Chang et al.,2019) (AAAI&#x27;19)</td><td>27.3</td><td>49.8</td><td>-</td><td>1</td><td>28.3</td><td>61.2</td><td>1</td><td>-</td></tr><tr><td>BUC (Lin et al.,2019) (AAAI&#x27;19)</td><td>27.5</td><td>47.4</td><td>62.6</td><td>68.4</td><td>38.3</td><td>66.2</td><td>79.6</td><td>84.5</td></tr><tr><td>ARN (Li et al.,2018) (CVPR&#x27;18-WS)</td><td>33.4</td><td>60.2</td><td>73.9</td><td>79.5</td><td>39.4</td><td>70.3</td><td>80.4</td><td>86.3</td></tr><tr><td>UDAP(Song et al.,2018) (Arxiv&#x27;18)</td><td>49.0</td><td>68.4</td><td>80.1</td><td>83.5</td><td>53.7</td><td>75.8</td><td>89.5</td><td>93.2</td></tr><tr><td>ENC (Zhong et al.,2019) (CVPR&#x27;19)</td><td>40.4</td><td>63.3</td><td>75.8</td><td>80.4</td><td>43.0</td><td>75.1</td><td>87.6</td><td>91.6</td></tr><tr><td>UCDA-CCE(Qi et al.,2019) (ICCV&#x27;19)</td><td>31.0</td><td>47.7</td><td></td><td>-</td><td>30.9</td><td>60.4</td><td>-</td><td>-</td></tr><tr><td>PDA-Net (Li et al.,2019) (ICCV&#x27;19)</td><td>45.1</td><td>63.2</td><td>77.0</td><td>82.5</td><td>47.6</td><td>75.2</td><td>86.3</td><td>90.2</td></tr><tr><td>PCB-PAST(Zhang et al.,2019b) (ICCV&#x27;19)</td><td>54.3</td><td>72.4</td><td>-</td><td>-</td><td>54.6</td><td>78.4</td><td>-</td><td>-</td></tr><tr><td>SSG (Yang et al.,2019) (ICCV&#x27;19)</td><td>53.4</td><td>73.0</td><td>80.6</td><td>83.2</td><td>58.3</td><td>80.0</td><td>90.0</td><td>92.4</td></tr><tr><td>Co-teaching (Han et al.,2018)-500 (ResNet-50)</td><td>55.7</td><td>71.9</td><td>83.5</td><td>88.1</td><td>65.1</td><td>82.5</td><td>91.8</td><td>93.4</td></tr><tr><td>Co-teaching (Han et al.,2018)-500 (IBN-ResNet-50)</td><td>61.7</td><td>77.6</td><td>88.0</td><td>90.7</td><td>71.7</td><td>87.8</td><td>95.0</td><td>96.5</td></tr><tr><td>Pre-trained (ResNet-50)</td><td>29.6</td><td>46.0</td><td>61.5</td><td>67.2</td><td>31.8</td><td>61.9</td><td>76.4</td><td>82.2</td></tr><tr><td>Proposed MMT-500 (ResNet-50)</td><td>63.1</td><td>76.8</td><td>88.0</td><td>92.2</td><td>71.2</td><td>87.7</td><td>94.9</td><td>96.9</td></tr><tr><td>Proposed MMT-700 (ResNet-50)</td><td>65.1</td><td>78.0</td><td>88.8</td><td>92.5</td><td>69.0</td><td>86.8</td><td>94.6</td><td>96.9</td></tr><tr><td>Proposed MMT-900 (ResNet-50)</td><td>63.1</td><td>77.4</td><td>88.1</td><td>92.5</td><td>66.2</td><td>86.8</td><td>94.9</td><td>96.6</td></tr><tr><td>Pre-trained (IBN-ResNet-50)</td><td>35.4</td><td>54.0</td><td>67.7</td><td>72.9</td><td>35.6</td><td>65.3</td><td>79.7</td><td>84.3</td></tr><tr><td>Proposed MMT-500 (IBN-ResNet-50)</td><td>65.7</td><td>79.3</td><td>89.1</td><td>92.4</td><td>76.5</td><td>90.9</td><td>96.4</td><td>97.9</td></tr><tr><td>Proposed MMT-700 (IBN-ResNet-50)</td><td>68.7</td><td>81.8</td><td>91.2</td><td>93.4</td><td>74.5</td><td>91.1</td><td>96.5</td><td>98.2</td></tr><tr><td>Proposed MMT-900 (IBN-ResNet-50)</td><td>67.3</td><td>80.8</td><td>90.3</td><td>93.0</td><td>72.7</td><td>91.2</td><td>96.3</td><td>98.0</td></tr><tr><td rowspan="2">Methods</td><td></td><td>Market-to-MSMT</td><td></td><td></td><td></td><td>Duke-to-MSMT</td><td></td><td></td></tr><tr><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td></tr><tr><td>PTGAN(Wei et al.,2018) (CVPR&#x27;18)</td><td>2.9</td><td>10.2</td><td>-</td><td>24.4</td><td>3.3</td><td>11.8</td><td>-</td><td>27.4</td></tr><tr><td>ENC (Zhong et al.,2019) (CVPR&#x27;19)</td><td>8.5</td><td>25.3</td><td>36.3</td><td>42.1</td><td>10.2</td><td>30.2</td><td>41.5</td><td>46.8</td></tr><tr><td>SSG (Yang et al.,2019) (ICCV&#x27;19)</td><td>13.2</td><td>31.6</td><td>-</td><td>49.6</td><td>13.3</td><td>32.2</td><td>1</td><td>51.2</td></tr><tr><td>Pre-trained (ResNet-50)</td><td>7.1</td><td>19.4</td><td>28.9</td><td>34.2</td><td>9.4</td><td>27.0</td><td>38.1</td><td>43.7</td></tr><tr><td>Proposed MMT-500 (ResNet-50)</td><td>16.6</td><td>37.5</td><td>50.6</td><td>56.5</td><td>17.9</td><td>41.3</td><td>54.2</td><td>59.7</td></tr><tr><td>Proposed MMT-1000 (ResNet-50)</td><td>21.6</td><td>46.1</td><td>59.8</td><td>66.1</td><td>23.5</td><td>50.0</td><td>63.6</td><td>69.2</td></tr><tr><td>Proposed MMT-1500 (ResNet-50)</td><td>22.9</td><td>49.2</td><td>63.1</td><td>68.8</td><td>23.3</td><td>50.1</td><td>63.9</td><td>69.8</td></tr><tr><td>Proposed MMT-2000 (ResNet-50)</td><td>20.8</td><td>45.7</td><td>59.6</td><td>65.6</td><td>22.4</td><td>49.0</td><td>62.5</td><td>67.8</td></tr><tr><td>Pre-trained (IBN-ResNet-50)</td><td>9.5</td><td>25.3</td><td>36.2</td><td>41.6</td><td>11.9</td><td>32.6</td><td>44.7</td><td>50.4</td></tr><tr><td>Proposed MMT-500 (IBN-ResNet-50)</td><td>19.6</td><td>43.3</td><td>56.1</td><td>61.6</td><td>23.3</td><td>50.0</td><td>62.8</td><td>68.4</td></tr><tr><td>Proposed MMT-1000 (IBN-ResNet-50)</td><td>26.3</td><td>52.5</td><td>66.3</td><td>71.7</td><td>29.7</td><td>58.8</td><td>71.0</td><td>76.1</td></tr><tr><td>Proposed MMT-1500 (IBN-ResNet-50)</td><td>26.6</td><td>54.4</td><td>67.6</td><td>72.9</td><td>29.3</td><td>58.2</td><td>71.6</td><td>76.8</td></tr><tr><td>Proposed MMT-2000 (IBN-ResNet-50)</td><td>25.1</td><td>52.7</td><td>65.9</td><td>71.3</td><td>28.1</td><td>56.8</td><td>70.8</td><td>76.0</td></tr></table>
+
+# 4.3 COMPARISON WITH STATE-OF-THE-ARTS
+
+We compare our proposed MMT framework with state-of-the-art methods on the four domain adaptation tasks, Market-to-Duke, Duke-to-Market, Market-to-MSMT and Duke-to-MSMT. The results are shown in Table 1. Our MMT framework significantly outperforms all existing approaches with both ResNet-50 and IBN-ResNet-50 backbones, which verifies the effectiveness of our method. Moreover, we almost approach fully-supervised learning performances (Sun et al., 2018; Ge et al., 2018) without any manual annotations on the target domain. No post-processing technique, e.g. re-ranking (Zhong et al., 2017a) or multi-query fusion (Zheng et al., 2015), is adopted.
+
+Specifically, by adopting the ResNet-50 (He et al., 2016) backbone, we surpass the state-of-theart clustering-based SSG (Yang et al., 2019) by considerable margins of $1 1 . 7 \%$ and $12 . 9 \%$ mAP on Market-to-Duke and Duke-to-Market tasks with simpler network architectures and lower output feature dimensions. Furthermore, evident $9 . 7 \%$ and $1 0 . 2 \%$ mAP gains are achieved on Market-toMSMT and Duke-to-MSMT tasks. Recall that $M _ { t }$ is the number of clusters or number of hard pseudo labels manually specified. More importantly, we achieve state-of-the-art performances on all tested target datasets with different $M _ { t }$ , which are either fewer or more than the actual number of identities in the training set of the target domain. Such results prove the necessity and effectiveness of our proposed pseudo label refinery for hard pseudo labels with inevitable noises.
+
+Table 2: Ablation studies of our proposed MMT on Duke-to-Market and Market-to-Duke tasks with $M _ { t }$ of 500. Note that the actual numbers of identities are not equal to 500 for both datasets but our MMT method still shows significant improvements.   
+
+<table><tr><td rowspan="2">Duke-to-Market</td><td colspan="4">IBN-ResNet-50</td><td colspan="4">ResNet-50</td></tr><tr><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td></tr><tr><td>Pre-trained(onlyLid&amp;Lri)</td><td>35.6</td><td>65.3</td><td>79.7</td><td>84.3</td><td>31.8</td><td>61.9</td><td>76.4</td><td>82.2</td></tr><tr><td>Baseline (only L&amp; Lr</td><td>62.7</td><td>84.4</td><td>92.7</td><td>95.5</td><td>53.5</td><td>76.0</td><td>88.1</td><td>91.9</td></tr><tr><td></td><td>34.5</td><td>59.7</td><td>73.0</td><td>78.0</td><td>22.4</td><td>46.5</td><td>61.5</td><td>67.4</td></tr><tr><td>Baseline+MMT-500 (w/oCd）</td><td>38.0</td><td>63.4</td><td>74.9</td><td>79.4</td><td>24.9</td><td>50.3</td><td>64.0</td><td>69.8</td></tr><tr><td></td><td>76.2</td><td>90.8</td><td>96.6</td><td>97.9</td><td>72.0</td><td>87.8</td><td>95.5</td><td>96.9</td></tr><tr><td>Baseline+MMT-500 (w/oCd）</td><td>69.6</td><td>87.4</td><td>95.2</td><td>96.7</td><td>62.6</td><td>84.0</td><td>93.4</td><td>95.4</td></tr><tr><td>Baseline+MMT-500(wloC)</td><td>71.7</td><td>88.5</td><td>95.1</td><td>96.6</td><td>65.9</td><td>84.0</td><td>93.1</td><td>95.5</td></tr><tr><td>Baseline+MMT-500(w/o02）</td><td>72.8</td><td>89.1</td><td>95.2</td><td>97.1</td><td>67.5</td><td>86.1</td><td>94.3</td><td>96.1</td></tr><tr><td>Baseline+MMT-500 (w/o E[0])</td><td>72.1</td><td>88.7</td><td>95.4</td><td>97.3</td><td>62.3</td><td>80.5</td><td>91.3</td><td>94.0</td></tr><tr><td>Baseline+MMT-500</td><td>76.5</td><td>90.9</td><td>96.4</td><td>97.9</td><td>71.2</td><td>87.7</td><td>94.9</td><td>96.9</td></tr><tr><td rowspan="2">Market-to-Duke</td><td></td><td>IBN-ResNet-50</td><td></td><td></td><td></td><td>ResNet-50</td><td></td><td></td></tr><tr><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td><td>mAP</td><td>top-1</td><td>top-5</td><td>top-10</td></tr><tr><td>Pre-trained (onlyLid&amp;Lri）</td><td>35.4</td><td>54.0</td><td>67.7</td><td>72.9</td><td>29.6</td><td>46.0</td><td>61.5</td><td>67.2</td></tr><tr><td>Baseline (only C&amp;Ct）</td><td>55.0</td><td>72.3</td><td>84.4</td><td>88.1</td><td>48.2</td><td>66.4</td><td>79.8</td><td>84.0</td></tr><tr><td></td><td>24.5</td><td>38.0</td><td>50.1</td><td>56.1</td><td>13.6</td><td>24.3</td><td>36.4</td><td>42.5</td></tr><tr><td>Baseline+MMT-500 (w/oCd）</td><td>27.5</td><td>42.0</td><td>53.9</td><td>60.3</td><td>15.3</td><td>25.8</td><td>37.7</td><td>43.7</td></tr><tr><td></td><td>65.6</td><td>79.4</td><td>89.8</td><td>92.3</td><td>63.0</td><td>77.3</td><td>88.3</td><td>91.6</td></tr><tr><td>Baseline+MMT-500 (w/od)</td><td>60.3</td><td>75.7</td><td>86.6</td><td>89.9</td><td>58.1</td><td>74.9</td><td>85.2</td><td>89.5</td></tr><tr><td>Baseline+MMT-500 (w/o)</td><td>61.7</td><td>77.1</td><td>86.5</td><td>89.6</td><td>59.5</td><td>73.9</td><td>85.5</td><td>88.8</td></tr><tr><td>Baseline+MMT-500 (w/o02）</td><td>62.1</td><td>77.6</td><td>86.8</td><td>89.7</td><td>58.2</td><td>74.1</td><td>86.0</td><td>89.3</td></tr><tr><td>Baseline+MMT-500 (w/o E[0])</td><td>61.1</td><td>76.3</td><td>86.6</td><td>89.8</td><td>55.7</td><td>70.0</td><td>83.6</td><td>87.2</td></tr><tr><td>Baseline+MMT-500</td><td>65.7</td><td>79.3</td><td>89.1</td><td>92.4</td><td>63.1</td><td>76.8</td><td>88.0</td><td>92.2</td></tr></table>
+
+To compare with relevant methods for tackling general noisy label problems, we implement Coteaching (Han et al., 2018) on unsupervised person re-ID task with 500 pseudo identities on the target domain, where the noisy labels are generated by the same clustering algorithm as our MMT framework. The hard classification (cross-entropy) loss is adopted on selected clean batches. All the hyper-parameters are set as the same for fair comparison, and the experimental results are denoted as “Co-teaching (Han et al., 2018)- $. 5 0 0 ^ { \circ }$ with both ResNet-50 and IBN-ResNet-50 backbones in Table 1. Comparing “Co-teaching (Han et al., 2018)-500 (ResNet-50)” with “Proposed MMT-500 (ResNet-50)”, we observe significant $7 . 4 \%$ and $6 . 1 \%$ mAP drops on Market-to-Duke and Duketo-Market tasks respectively, since Co-teaching (Han et al., 2018) is designed for general close-set recognition problems with manually generated label noise, which could not tackle the real-world challenges in unsupervised person re-ID. More importantly, it does not explore how to mitigate the label noise for the triplet loss as our method does.
+
+# 4.4 ABLATION STUDIES
+
+In this section, we evaluate each component in our proposed framework by conducting ablation studies on Duke-to-Market and Market-to-Duke tasks with both ResNet-50 (He et al., 2016) and IBN-ResNet-50 (Pan et al., 2018) backbones. Results are shown in Table 2.
+
+Effectiveness of the soft pseudo label refinery. To investigate the necessity of handling noisy pseudo labels in clustering-based UDA methods, we create baseline models that utilize only off-line refined hard pseudo labels, i.e., optimizing equation 9 with $\lambda _ { i d } ^ { t } = \lambda _ { t r i } ^ { t } = 0$ for the two-step training strategy in Section 3.1. The baseline model performances are present in Table 2 as “Baseline (only $\mathcal { L } _ { i d } ^ { t }$ & $\mathcal { L } _ { t r i } ^ { t }$ )”. Considerable drops of $1 7 . 7 \%$ and $1 4 . 9 \%$ mAP are observed on ResNet-50 for Duketo-Market and Market-to-Duke tasks. Similarly, $1 3 . 8 \%$ and $1 0 . 7 \%$ mAP decreases are shown on the IBN-ResNet-50 backbone. Stable increases achieved by the proposed on-line refined soft pseudo labels on different datasets and backbones demonstrate the necessity of soft pseudo label refinery and the effectiveness of our proposed MMT framework.
+
+Effectiveness of the soft softmax-triplet loss. We also verify the effectiveness of soft softmaxtriplet loss with softly refined triplet labels in our proposed MMT framework. Experiments of removing the soft softmax-triplet loss, i.e., $\lambda _ { t r i } ^ { t } = 0$ in equation 9, but keeping the hard softmaxtriplet loss (equation 6) are conducted, which are denoted as “Baseline+MMT-500 (w/o $\boldsymbol { \mathcal { L } } _ { s t r i } ^ { t } ) ^ { * }$ . All experiments without the supervision of soft triplet loss show distinct drops on Duke-to-Market and Market-to-Duke tasks, which indicate that the hard pseudo label with hard triplet loss hinders the feature learning capability because it ignores pseudo label noise by the clustering algorithms.
+
+Specifically, the mAP drops are $5 . 3 \%$ on ResNet-50 and $4 . 8 \%$ on IBN-ResNet-50 when evaluating on the target dataset Market-1501. As for the Market-to-Duke task, similar mAP drops of $3 . 6 \%$ and $4 . 0 \%$ on the two network structures can be observed. An evident improvement of up to $5 . 3 \%$ mAP demonstrates the usefulness of our proposed soft softmax-triplet loss.
+
+Effectiveness of Mutual Mean-Teaching. We propose to generate on-line refined soft pseudo labels for one network with the predictions of the past average model of the other network in our MMT framework, i.e., the soft labels for network 1 are output from the average model of network 2 and vice versa. We observe that the soft labels generated in such manner are more reliable due to the better decoupling between the past temporally average models of the two networks. Such a framework could effectively avoid bias amplification even when the networks have much erroneous outputs in the early training epochs. There are two possible simplification our MMT framework with less de-coupled structures. The first one is to keep only one network in our framework and use its past temporal average model to generate soft pseudo labels for training itself. Such experiments are denoted as “Baseline+MMT-500 (w/o $\pmb { \theta } _ { 2 }$ )”. The second simplification is to na¨ıvely use one network’s current-iteration predictions as the soft pseudo labels for training the other network and vice versa, i.e., $\alpha = 0$ for equation 4. This set of experiments are denoted as “Baseline+MMT-500 (w/o $E [ \pmb \theta ] )$ ”. Significant mAP drops compared to our proposed MMT could be observed in the two sets of experiments, especially when using the ResNet-50 backbone, e.g. the mAP drops by $8 . 9 \%$ on Duke-to-Market task when removing past average models. This validates the necessity of employing the proposed mutual mean-teaching scheme for providing more robust soft pseudo labels. In despite of the large margin of performance declines when removing either the peer network or the past average model, our proposed MMT outperforms the baseline model significantly, which further demonstrates the importance of adopting the proposed on-line refined soft pseudo labels.
+
+Necessity of hard pseudo labels in proposed MMT. Despite the robust soft pseudo labels bring significant improvements, the noisy hard pseudo labels are still essential to our proposed framework, since the hard classification loss $\mathcal { L } _ { i d } ^ { t ^ { - } }$ is the foundation for capturing the target-domain data distributions. To investigate the contribution of $\mathcal { L } _ { i d } ^ { t }$ in the final training objective function as equation 9, we conduct two experiments. (1) “Baseline+MMT-500 (only $\bar { \mathcal { L } } _ { s i d } ^ { t }$ & $\mathcal { L } _ { s t r i } ^ { t } ) ^ { \flat }$ by removing both hard classification loss and hard triplet loss with $\lambda _ { i d } ^ { t } = \lambda _ { t r i } ^ { t } = \breve { 1 }$ ; (2)“Baseline+MMT-500 (w/o $\mathcal { L } _ { i d } ^ { t } ) ^ { \flat }$ by removing only hard classification loss with $\lambda _ { i d } ^ { t } = 1$ . As illustrated in Table 2, the above two experiments both result in much lower performances than the model pre-trained on the source domain (“Pre-trained (only $\mathcal { L } _ { i d } ^ { s }$ & $\mathcal { L } _ { t r i } ^ { s } ) {  { \mathrm { ^ { , } } } }$ , which effectively validate the necessity of $\mathcal { L } _ { i d } ^ { t }$ . The initial network usually outputs uniform probabilities for each identity, which act as soft labels for soft classification loss, since it could not correctly distinguish between different identities on the target domain. Directly training with such smooth and noisy soft pseudo labels, the networks in our framework would soon collapse due to the large bias. One-hot hard labels for classification loss are critical for learning discriminative representations on the target domain. In contrast, the hard triplet loss $\mathcal { L } _ { t r i } ^ { t }$ is not absolutely necessary in our framework, as experiments without $\mathcal { L } _ { t r i } ^ { t }$ , denoted as “Baseline+MMT-500 (w/o $\bar { \mathcal { L } } _ { t r i } ^ { t } ) ^ { \flat }$ with $\bar { \lambda } _ { t r i } ^ { t } = 1 . 0$ , show similar performances as our final results with $\lambda _ { t r i } ^ { t } = 0 . 8$ . It is much easier to learn to predict robust soft labels for the soft softmax-triplet loss in equation 8 even at early training epochs, which has only two classes, i.e., positive and negative.
+
+# 5 CONCLUSION
+
+In this work, we propose an unsupervised Mutual Mean-Teaching (MMT) framework to tackle the problem of noisy pseudo labels in clustering-based unsupervised domain adaptation methods for person re-ID. The key is to conduct pseudo label refinery to better model inter-sample relations in the target domain by optimizing with the off-line refined hard pseudo labels and on-line refined soft pseudo labels in a collaborative training manner. Moreover, a novel soft softmax-triplet loss is proposed to support learning with softly refined triplet labels for optimal performances. Our method significantly outperforms all existing person re-ID methods on domain adaptation task with up to $1 8 . 2 \%$ improvements.
+
+# ACKNOWLEDGMENTS
+
+This work is supported by the General Research Fund sponsored by the Research Grants Council of Hong Kong (Nos. CUHK14208417, CUHK14239816, CUHK14207319), the Hong Kong Innovation and Technology Support Program (No. ITS/312/18FX).
+
+# REFERENCES
+
+Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. In NIPS, 2016.
+
+Xiaobin Chang, Yongxin Yang, Tao Xiang, and Timothy M Hospedales. Disjoint label space transfer learning with common factorised space. AAAI, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. 2009.
+
+Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In CVPR, pp. 4690–4699, 2019.
+
+Weijian Deng, Liang Zheng, Qixiang Ye, Guoliang Kang, Yi Yang, and Jianbin Jiao. Imageimage domain adaptation with preserved self-similarity and domain-dissimilarity for person reidentification. In CVPR, 2018.
+
+Hehe Fan, Liang Zheng, Chenggang Yan, and Yi Yang. Unsupervised person re-identification: Clustering and fine-tuning. 2018.
+
+Yixiao Ge, Zhuowan Li, Haiyu Zhao, Guojun Yin, Shuai Yi, Xiaogang Wang, et al. Fd-gan: Poseguided feature distilling gan for robust person re-identification. In NeurIPS, 2018.
+
+Muhammad Ghifary, W Bastiaan Kleijn, Mengjie Zhang, David Balduzzi, and Wen Li. Deep reconstruction-classification networks for unsupervised domain adaptation. In ECCV, 2016.
+
+Aritra Ghosh, Himanshu Kumar, and PS Sastry. Robust loss functions under label noise for deep neural networks. In AAAI, 2017.
+
+Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In NIPS, pp. 8527–8537, 2018.
+
+Jiangfan Han, Ping Luo, and Xiaogang Wang. Deep self-learning from noisy labels. In ICCV, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Alexander Hermans, Lucas Beyer, and Bastian Leibe. In defense of the triplet loss for person reidentification. arXiv preprint arXiv:1703.07737, 2017.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.
+
+Kuang-Huei Lee, Xiaodong He, Lei Zhang, and Linjun Yang. Cleannet: Transfer learning for scalable image classifier training with label noise. In CVPR, pp. 5447–5456, 2018.
+
+Yu-Jhe Li, Fu-En Yang, Yen-Cheng Liu, Yu-Ying Yeh, Xiaofei Du, and Yu-Chiang Frank Wang. Adaptation and re-identification network: An unsupervised deep transfer learning approach to person re-identification. In CVPRW, 2018.
+
+Yu-Jhe Li, Ci-Siang Lin, Yan-Bo Lin, and Yu-Chiang Frank Wang. Cross-dataset person reidentification via unsupervised pose disentanglement and adaptation. ICCV, 2019.
+
+Yuncheng Li, Jianchao Yang, Yale Song, Liangliang Cao, Jiebo Luo, and Li-Jia Li. Learning from noisy labels with distillation. In ICCV, pp. 1910–1918, 2017.
+
+Yutian Lin, Xuanyi Dong, Liang Zheng, Yan Yan, and Yi Yang. A bottom-up clustering approach to unsupervised person re-identification. In AAAI, 2019.
+
+Mingsheng Long, Yue Cao, Jianmin Wang, and Michael I Jordan. Learning transferable features with deep adaptation networks. arXiv preprint arXiv:1502.02791, 2015.
+
+Hao Luo, Youzhi Gu, Xingyu Liao, Shenqi Lai, and Wei Jiang. Bag of tricks and a strong baseline for deep person re-identification. In CVPRW, 2019.
+
+Rafael Muller, Simon Kornblith, and Geoffrey Hinton. When does label smoothing help? ¨ arXiv preprint arXiv:1906.02629, 2019.
+
+Xingang Pan, Ping Luo, Jianping Shi, and Xiaoou Tang. Two at once: Enhancing learning and generalization capacities via ibn-net. In ECCV, 2018.
+
+Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, pp. 1944–1952, 2017.
+
+Lei Qi, Lei Wang, Jing Huo, Luping Zhou, Yinghuan Shi, and Yang Gao. A novel unsupervised camera-aware domain adaptation framework for person re-identification. ICCV, 2019.
+
+Ergys Ristani, Francesco Solera, Roger Zou, Rita Cucchiara, and Carlo Tomasi. Performance measures and a data set for multi-target, multi-camera tracking. In ECCVW, 2016.
+
+Kuniaki Saito, Kohei Watanabe, Yoshitaka Ushiku, and Tatsuya Harada. Maximum classifier discrepancy for unsupervised domain adaptation. In CVPR, 2018.
+
+Liangchen Song, Cheng Wang, Lefei Zhang, Bo Du, Qian Zhang, Chang Huang, and Xinggang Wang. Unsupervised domain adaptive re-identification: Theory and practice. arXiv preprint arXiv:1807.11334, 2018.
+
+Yifan Sun, Liang Zheng, Yi Yang, Qi Tian, and Shengjin Wang. Beyond part models: Person retrieval with refined part pooling (and a strong convolutional baseline). In ECCV, 2018.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, pp. 2818–2826, 2016.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NIPS, 2017.
+
+Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014.
+
+Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In CVPR, 2015.
+
+Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In CVPR, 2017.
+
+Arash Vahdat. Toward robustness against label noise in training deep discriminative neural networks. In NIPS, pp. 5596–5605, 2017.
+
+Andreas Veit, Neil Alldrin, Gal Chechik, Ivan Krasin, Abhinav Gupta, and Serge Belongie. Learning from noisy large-scale datasets with minimal supervision. In CVPR, pp. 839–847, 2017.
+
+Jingya Wang, Xiatian Zhu, Shaogang Gong, and Wei Li. Transferable joint attribute-identity deep learning for unsupervised person re-identification. In CVPR, 2018.
+
+Xiaobo Wang, Shuo Wang, Jun Wang, Hailin Shi, and Tao Mei. Co-mining: Deep face recognition with noisy labels. In ICCV, pp. 9358–9367, 2019.
+
+Longhui Wei, Shiliang Zhang, Wen Gao, and Qi Tian. Person transfer gan to bridge domain gap for person re-identification. In CVPR, 2018.
+
+Tong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. In CVPR, pp. 2691–2699, 2015.
+
+Hongliang Yan, Yukang Ding, Peihua Li, Qilong Wang, Yong Xu, and Wangmeng Zuo. Mind the class weight bias: Weighted maximum mean discrepancy for unsupervised domain adaptation. In CVPR, 2017.
+
+Fu Yang, Wei Yunchao, Wang Guanshuo, Zhou Yuqian, Shi Honghui, and Huang Thomas. Selfsimilarity grouping: A simple unsupervised cross domain adaptation approach for person reidentification. ICCV, 2019.
+
+Hong-Xing Yu, Wei-Shi Zheng, Ancong Wu, Xiaowei Guo, Shaogang Gong, and Jian-Huang Lai. Unsupervised person re-identification by soft multilabel learning. In CVPR, 2019.
+
+Ji Zhang, Yannis Kalantidis, Marcus Rohrbach, Manohar Paluri, Ahmed Elgammal, and Mohamed Elhoseiny. Large-scale visual relationship understanding. In AAAI, 2019a.
+
+Weichen Zhang, Wanli Ouyang, Wen Li, and Dong Xu. Collaborative and adversarial network for unsupervised domain adaptation. In CVPR, 2018a.
+
+Xinyu Zhang, Jiewei Cao, Chunhua Shen, and Mingyu You. Self-training with progressive augmentation for unsupervised cross-domain person re-identification. ICCV, 2019b.
+
+Ying Zhang, Tao Xiang, Timothy M Hospedales, and Huchuan Lu. Deep mutual learning. In CVPR, 2018b.
+
+Zhilu Zhang and Mert Sabuncu. Generalized cross entropy loss for training deep neural networks with noisy labels. In NIPS, pp. 8778–8788, 2018.
+
+Liang Zheng, Liyue Shen, Lu Tian, Shengjin Wang, Jingdong Wang, and Qi Tian. Scalable person re-identification: A benchmark. In ICCV, 2015.
+
+Zhun Zhong, Liang Zheng, Donglin Cao, and Shaozi Li. Re-ranking person re-identification with k-reciprocal encoding. In CVPR, 2017a.
+
+Zhun Zhong, Liang Zheng, Guoliang Kang, Shaozi Li, and Yi Yang. Random erasing data augmentation. arXiv preprint arXiv:1708.04896, 2017b.
+
+Zhun Zhong, Liang Zheng, Shaozi Li, and Yi Yang. Generalizing a person retrieval model heteroand homogeneously. In ECCV, 2018.
+
+Zhun Zhong, Liang Zheng, Zhiming Luo, Shaozi Li, and Yi Yang. Invariance matters: Exemplar memory for domain adaptive person re-identification. In CVPR, 2019.
+
+# A APPENDIX
+
+# A.1 FUNCTIONS OF TEMPORAL AVERAGE MODELS IN MMT
+
+![](images/deb81fa58a66105acdc6464a88f9736b9106427683d286019719808b55485c4b.jpg)  
+Figure 3: The predictions of temporal average models (denoted as “Proposed MMT-500”) serve as more complementary and robust soft pseudo labels than those of ordinary networks (denoted as “Proposed MMT-500 (w/o $E [ \pmb { \theta } ] ) ^ { * }$ ).
+
+Two temporal average models are introduced in our proposed MMT framework to provide more complementary soft labels and avoid training error amplification. Such average models are more de-coupled by ensembling the past parameters and provide more independent predictions, which is ignored by previous methods with peer-teaching strategy (Han et al., 2018; Wang et al., 2019; Zhang et al., 2018b). Despite we have verified the effectiveness of such design in Table 2 by removing the temporal average model, denoted as “Baseline+MMT-500 (w/o $E [ \pmb \theta ] ) ^ { : }$ ”, we would like to visualize the training process by plotting the KL divergence between peer networks’ predictions for further comparison. As illustrated in Figure 3, the predictions by two temporal average models (“Proposed MMT-500”) always keep a larger distance than predictions by two ordinary networks (“Proposed MMT-500 (w/o $\dot { E } [ \pmb { \theta } ] ) ^ { \ast \ast } ,$ , which indicates that the temporal average models could prevent the two networks in our MMT from converging to each other soon under the collaborative training strategy.
+
+# A.2 PARAMETER ANALYSIS
+
+![](images/ea725d419497b6d217491ead31fa468e802b8e3c6bab16885551ffc4a6fc7569.jpg)  
+Figure 4: Performance evaluation of our proposed MMT-500 with different values of $\lambda _ { t r i } ^ { t }$ and $\lambda _ { i d } ^ { t }$ in equation 9 on Duke-to-Market and Market-to-Duke tasks in terms of $\mathrm { m A P ( \% ) }$ and top- $1 ( \% )$ accuracies. Weighting factors $\lambda _ { t r i } ^ { t }$ and $\lambda _ { i d } ^ { t }$ balance the contributions between hard and soft pseudo labels. Specifically, only hard labels are adopted when the weighting factors are set to 0.0, and only soft labels are utilized when the weighting factors are set to 1.0.
+
+We utilize weighting factors of $\lambda _ { t r i } ^ { t } = 0 . 8$ , ${ \lambda } _ { i d } ^ { t } = 0 . 5$ in all our experiments by tuning on Duketo-Market task with IBN-ResNet-50 backbone and 500 pseudo identities. To further analyse the impact of different $\lambda _ { t r i } ^ { t }$ and $\lambda _ { i d } ^ { t }$ on different tasks, we conduct comparison experiments by varying the value of one parameter and keep the others fixed. Our MMT framework is robust and insensitive to different parameters except when the hard classification loss is eliminated with ${ \lambda } _ { i d } ^ { t } = 1 . 0$ .
+
+The weighting factor of hard and soft triplet losses $\lambda _ { t r i } ^ { t }$ . In Figure 4 (a-b), we investigate the effect of the weighting factor $\lambda _ { t r i } ^ { t }$ in equation 9, where the weight for soft softmax-triplet loss is $\lambda _ { t r i } ^ { t }$ and the weight for hard triplet loss is $( 1 - \lambda _ { t r i } ^ { t } )$ . We test our proposed MMT-500 with both ResNet-50 and IBN-ResNet-50 backbones when $\lambda _ { t r i } ^ { t }$ is varying from 0.0, 0.3, 0.5, 0.8 and 1.0. Specifically, the soft softmax-triplet loss is removed from the final training objective (equation 9) when $\lambda _ { t r i } ^ { t }$ is equal to 0.0, and the hard triplet loss is eliminated when $\lambda _ { t r i } ^ { t }$ is set to 1.0. We observe that the accuracies are almost in direct ratio to the value of $\lambda _ { t r i } ^ { t }$ which indicate the effectiveness of our proposed novel soft softmax-triplet loss. MMT-500 achieves optimal performances with ResNet-50 backbone on both two tasks when $\lambda _ { t r i } ^ { t } = 1 . 0$ . With the backbone of IBN-ResNet-50, MMT-500 obtains the best results with $\lambda _ { t r i } ^ { t } = 0 . 8$ on Duke-to-Market and $\lambda _ { t r i } ^ { t } = 0 . 5$ on Marketto-Duke. Despite the performances vary with different values of $\lambda _ { t r i } ^ { t }$ , all the results by our method outperform state-of-the-arts significantly.
+
+The weighting factor of hard and soft classification losses $\lambda _ { i d } ^ { t }$ . Similar to the comparisons of $\lambda _ { t r i } ^ { t }$ , we evaluate our proposed MMT-500 framework with different values of $\lambda _ { i d } ^ { t }$ , which is the weighting factor for hard and soft classification losses in equation 9. As illustrated in Figure 4 (c-d), we observe considerable declines when the hard classification loss equation 1 is eliminated with ${ \lambda } _ { i d } ^ { t } = 1 . 0$ . Hard classification loss is essential to our proposed framework, which is fully analysed in Section 4.4. We achieve the optimal performances on both two tasks when ${ \lambda } _ { i d } ^ { t } = 0 . 5$ , while all the experiments with $\lambda _ { i d } ^ { t } < 1$ outperform state-of-the-arts by large margins.

parse/train/uAX8q61EVRu/uAX8q61EVRu.md

@@ -0,0 +1,587 @@
+# NEURAL SYNTHESIS OF BINAURAL SPEECH FROM MONO AUDIO
+
+Alexander Richard, Dejan Markovic, Israel D. Gebru, Steven Krenn, Gladstone Butler, Fernando de la Torre, Yaser Sheikh
+
+Facebook Reality Labs   
+Pittsburgh, USA   
+{richardalex,dejanmarkovic,idgebru,stevenkrenn,gsbutler,yaser}@fb.com
+
+# ABSTRACT
+
+We present a neural rendering approach for binaural sound synthesis that can produce realistic and spatially accurate binaural sound in realtime. The network takes, as input, a single-channel audio source and synthesizes, as output, twochannel binaural sound, conditioned on the relative position and orientation of the listener with respect to the source. We investigate deficiencies of the $\ell _ { 2 }$ -loss on raw wave-forms in a theoretical analysis and introduce an improved loss that overcomes these limitations. In an empirical evaluation, we establish that our approach is the first to generate spatially accurate waveform outputs (as measured by real recordings) and outperforms existing approaches by a considerable margin, both quantitatively and in a perceptual study. Dataset and code are available online.1
+
+# 1 INTRODUCTION
+
+The rise of artificial spaces, in augmented and virtual reality, necessitates efficient production of accurate spatialized audio. Spatial hearing (the capacity to interpret spatial clues from binaural signals), not only helps us to orient ourselves in 3D environments, it also establishes immersion in the space by providing the brain with congruous acoustic and visual input (Hendrix & Barfield, 1996). Binaural audio (left and right ear) even guides us in multi-person conversations: consider a scenario where multiple persons are speaking in a video call, making it difficult to follow the conversation. In the same situation in a real environment we are able to effortlessly focus on the speech from an individual (Hawley et al., 2004). Indeed, auditory sensation has primacy over even visual sensation as an input modality for scene understanding: (1) reaction times are faster for auditory stimulus compared to visual stimulus (Jose & Praveen, 2010) (2) auditory sensing provides a surround understanding of space as opposed to the directionality of visual sensation. For these reasons, the generation of accurate binarual signal is integral to full immersion in artificial spaces.
+
+Most approaches to binaural audio generation rely on traditional digital signal processing (DSP) techniques, where each component – head related transfer function, room acoustics, ambient noise – is modeled as a linear time-invariant system (LTI) (Savioja et al., 1999; Zotkin et al., 2004; Sunder et al., 2015; Zhang et al., 2017). These linear systems are well-understood, relatively easy to model mathematically, and have been shown to produce perceptually plausible results – reasons why they are still widely used. Real acoustic propagation, however, has nonlinear wave effects that are not appropriately modeled by LTI systems. As a consequence, DSP approaches do not achieve perceptual authenticity in dynamic scenarios (Brinkmann et al., 2017), and fail to produce metrically accurate results, i.e., the generated waveform does not resemble recorded binaural audio well.
+
+In this paper, we present an end-to-end neural synthesis approach that overcomes many of these limitations by efficiently synthesizing accurate and precise binaural audio. The end-to-end learning scheme naturally captures the linear and nonlinear effects of sound wave propagation and, being fully convolutional, is efficient to execute on commodity hardware. Our major contributions are (1) a novel binarualization model that outperforms existing state of the art, (2) an analysis of the shortcomings of the $\ell _ { 2 }$ -loss on raw waveforms and a novel loss mitigating these shortcomings, (3) a real-world binaural dataset captured in a non-anechoic room.
+
+![](images/572272f9a7659ec802cc416021f0c916814b4335f36cd127b60ecc159f20354d.jpg)  
+Figure 1: System Overview. Given the source and listener position and orientation $c _ { 1 : T }$ at each time step, a single-channel input signal $x _ { 1 : T }$ is transformed into a binaural signal. The neural time warping module learns an accurate warp from the source position to the listeners left and right ear while respecting physical properties like monotonicity and causality. The Temporal ConvNet models nuanced effects like room reverberations or head- and ear-shape related modifications to the signal.
+
+Related Work. State of the art DSP techniques approach binaural sound spatialization as a stack of acoustic components, each of which is an LTI system. As accurate wave-based simulation of room impulse responses is computationally expensive and requires detailed geometry and material information, most real-time systems rely on simplified geometrical models (Valim ¨ aki et al., 2012; Savioja ¨ & Svensson, 2015). Head-related transfer functions are measured in an anechoic chamber (Li & Peissig, 2020) and high-quality spatialization requires binaural recordings at almost 10k different spatial positions (Armstrong et al., 2018). To generate binaural audio the DSP-based binaural renderers typically perform a series of convolutions with these component impulse responses (Savioja et al., 1999; Zotkin et al., 2004; Sunder et al., 2015; Zhang et al., 2017). For a more detailed discussion, see Appendix A.4.
+
+Given their success in speech synthesis (Wang et al., 2017), neural networks gained increased attention for audio generation recently. While most approaches focus on models in frequency domain (Choi et al., 2018; Vasquez & Lewis, 2019), raw waveform models were long neglected due to the difficulty to model long-range dependencies on a high-frequency audio signal. With the success of WaveNet (Van Den Oord et al., 2016) however, direct wave-to-wave modeling is of increasing interest (Fu et al., 2017; Luo & Mesgarani, 2018; Donahue et al., 2019) and shows major improvements in speech enhancement (Defossez et al., 2020) and denoising (Rethage et al., 2018), speech synthesis (Kalchbrenner et al., 2018), and music style translation (Mor et al., 2019).
+
+More recently, first steps towards neural sound spatialization have been undertaken. Gebru et al. (2021) showed that HRTFs can be implicitly learned by neural networks trained on raw waveforms. Focusing on predicting spatial sound conditioned on visual information, a work by Morgado et al. (2018) aims to spatialize sound conditioned on $3 6 0 ^ { \circ }$ video. Yet, their work is limited to first order ambisonics and can not model detailed binaural effects. More closely related is a line of papers originating from the 2.5D visual sound system by Gao & Grauman (2019b). In this work, binaural audio is generated conditioned on a video frame embedding such that object locations can contribute to where sound comes from. Yang et al. (2020); Lu et al. (2019); Zhou et al. (2020) build upon the same idea. Unfortunately, all these works have in common that they pose the spatialization task as an upmixing problem, i.e., their models are trained with a mixture of left and right ear binaural recording as pseudo mono input. By design, these methods fail to model time delays and reverberation effects caused by the difference between source and listener position.
+
+# 2 A NEURAL NETWORK FOR BINAURAL SYNTHESIS
+
+We consider the problem where a monaural (single-channel) signal $\boldsymbol { x } _ { 1 : T } = ( x _ { 1 } , \dots , x _ { T } )$ of length $T$ is to be transformed into a binaural (stereophonic) signal $y _ { 1 : T } ^ { ( l ) } , y _ { 1 : T } ^ { ( r ) }$ representing the listener’s left ear and right ear, given a conditioning temporal signal $c _ { 1 : T }$ . This conditioning signal is the position and orientation of source and listener, respectively. Here $x _ { t }$ , and correspondingly $y _ { t } ^ { ( l ) }$ and $\bar { y } _ { t } ^ { ( r ) }$ , ar e scalars representing an audio sample at time $t$ . In other words, we aim to produce a function,
+
+$$
+\begin{array} { r } { \Big ( y _ { t } ^ { ( l ) } , y _ { t } ^ { ( r ) } \Big ) = f ( x _ { t - \Delta : t } | \pmb { c } _ { t - \Delta : t } ) , } \end{array}
+$$
+
+where $\Delta$ is a temporal receptive field. Each $\mathbf { } c _ { t } \in \mathbb { R } ^ { 1 4 }$ contains the 3D position of source and listener (three values each) and their orientations as quaternions (four values each). Note that in practice, $^ c$ often is of lower frequency than the input and output signals $x _ { 1 : T }$ and $y _ { 1 : T } ^ { ( l / r ) }$ – source and listener positions would likely not be updated at $4 8 \mathrm { k H z }$ but rather at typical camera frame rates such as 30- $1 2 0 \mathrm { H z }$ . To simplify notation, we assume that $^ c$ has already been upsampled to the same temporal resolution as the audio signals.
+
+Our overall framework is shown in Figure 1. A neural time warping module first warps the singlechannel input signal x1:T into a two-channel signal x(l/r)1:T , where the channels represent left and right ear. The time warping compensates for coarse temporal effects and differences in time of sound arrival at left and right ear caused by the distance between source and listener. The second block in Figure 1 is a stack of $N$ layers, each of which is a conditioned hyper-convolution (see Section 2.2) followed by a sine activation, which has been shown to be beneficial for modeling higher frequencies (Sitzmann et al., 2020). Following the design of WaveNet, we use kernel size 2 and double the dilation factor in each layer to increase the receptive field. This temporal ConvNet models nuanced effects caused by room reverberations, head and ear shape, or changing head orientations.
+
+# 2.1 NEURAL TIME WARPING
+
+Time warping is the task of mapping a source temporal sequence onto a target sequence and has a long tradition in temporal signal processing. Most prominently, dynamic time warping (DTW) finds application in tasks like speech recognition (Juang, 1984) or audio retrieval (Deng & Leung, 2015). DTW can be characterized as finding a warpfield $\rho _ { 1 : T }$ that warps a source signal $x _ { 1 : T }$ to a target signal $\hat { x } _ { 1 : T }$ such that the distance between the signals is minimized,
+
+$$
+\rho _ { 1 : T } = \underset { \tilde { \rho } _ { 1 : T } } { \mathrm { a r g } \mathrm { m i n } } \sum _ { t } \| \hat { x } _ { t } - x _ { \tilde { \rho } _ { t } } \| , \quad \mathrm { w h e r e } ~ \rho _ { t } \in \{ 1 , . . . , T \} ,
+$$
+
+where the warpfield is typically constrained to respect physical properties such as monotonicity $( \rho _ { t } \geq \rho _ { t - 1 } )$ and causality $( \rho _ { t } \leq t )$ .
+
+For binaural audio, there is a clear monotonous and causal relationship between source and target signal but the target signal is unknown at inference time. Additionally, the warping from mono to binaural signals goes far beyond simple linear time-shifts. For example, consider the source moving from the front to the left of the listener. This causes the delay between source and left ear to decrease but the delay between source and right ear to increase. If source and/or listener are moving, other wave effects such as the Doppler effect influence how the signal needs to be warped from the source to the listener’s left and right ear. We are therefore interested in estimating a warpfield from the conditioning input $c _ { 1 : T }$ , i.e., from the spatial position and orientation of source and listener. A simple, parameter-free approach is geometric warping based on the speed of sound $\nu _ { \mathrm { s o u n d } }$ and the distance between source and listener. Let $\mathbf { \nabla } _ { \mathbf { \mathcal { P } } _ { t } ^ { \mathrm { ( s r c ) } } }$ and $\pmb { p } _ { t } ^ { ( \mathrm { l s t n } ) }$ be the source and listener positions at time $t$ (which are part of $\mathbf { } _ { c _ { t } }$ ). Then,
+
+$$
+\rho _ { t } ^ { ( \mathrm { g e o m ) } } = t - \| p _ { t } ^ { ( \mathrm { s r c ) } } - p _ { t } ^ { ( \mathrm { l s t n } ) } \| \cdot \frac { \mathrm { a u d i o ~ s a m p l e ~ r a t e } } { \nu _ { \mathrm { s o u n d } } } .
+$$
+
+This approach, however, fails to model important nuances such as the displacement between the left and right ear or diffraction delays as sound travels around the listener’s head rather than straight through. In order to correct for those effects that geometric warping can not model properly, we estimate a neural warpfield ρ(neur1:T $\rho _ { 1 : T } ^ { ( \mathrm { n e u r a l } ) } = \mathrm { W a r p N e t } ( c _ { 1 : T } )$ and add it to the geometric warpfield (cf. Figure 1),
+
+$$
+\rho _ { t } = \sigma ^ { ( \mathrm { w a r p } ) } ( \rho _ { t - 1 } , \hat { \rho } _ { t } ) \quad \mathrm { w i t h } \quad \hat { \rho } _ { t } : = \rho _ { t } ^ { ( \mathrm { n e u r a l } ) } + \rho _ { t } ^ { ( \mathrm { g e o m } ) } ,
+$$
+
+where $\sigma ^ { ( \mathrm { w a r p } ) } ( \rho _ { t - 1 } , \hat { \rho } _ { t } ) \ = \ \mathrm { m a x } ( \rho _ { t - 1 } , \mathrm { m i n } ( t , \hat { \rho } _ { t } ) )$ is a recursive activation function that ensures monotonicity and causality. The WarpNet is a shallow temporal convolutional network with four layers and 64 channels each.
+
+The warped signal can now be computed using the predicted warpfield. Since the warpfield elements $\rho _ { t }$ are typically not integers, we define the warped signal $\hat { x } _ { 1 : T }$ to be the linear interpolation of the original signal $x _ { 1 : T }$ at positions $\lfloor \rho _ { t } \rfloor$ and $\lceil \rho _ { t } \rceil$ ,
+
+$$
+\begin{array} { r } { \hat { x } _ { t } = ( \lceil \rho _ { t } \rceil - \rho _ { t } ) \cdot x _ { \lfloor \rho _ { t } \rfloor } + ( \rho _ { t } - \lfloor \rho _ { t } \rfloor ) \cdot x _ { \lceil \rho _ { t } \rceil } . } \end{array}
+$$
+
+In practice two warpfields are generated, one for each ear. Note how we explicitly enforce physical constraints in the warping by $\sigma ^ { \mathrm { ( w a r p ) } }$ : $\operatorname* { m i n } ( t , { \hat { \rho } } _ { t } )$ ensures causality by enforcing that the $t$ -th element of the warpfield can not be larger than $t$ itself. Monotonicity is enforced by $\operatorname* { m a x } ( \rho _ { t - 1 } , \cdot )$ : if an element has been warped from $\rho _ { t - 1 }$ to position $t - 1$ , the next element at position $t$ must be warped from $\rho _ { t - 1 }$ or a succeeding position. In contrast to related approaches such as deformable convolutions (Dai et al., 2017) and spatial transformer networks (Jaderberg et al., 2015), our neural time warping therefore allows for constrained warping of input signals with arbitrary lengths and directly models a physical phenomenon of sound.
+
+# 2.2 CONDITIONED HYPER-CONVOLUTIONS
+
+Raw waveform models where the output depends on an input signal and an additional conditioning temporal signal have primarily been studied in speech synthesis (Van Den Oord et al., 2016). The predominant approach towards such conditional temporal convolutions is an additive combination of the input signal ${ \pmb x } _ { 1 : T }$ and the conditioning signal $c _ { 1 : T }$ , i.e., ${ \boldsymbol { z } } _ { 1 : T } = \mathbf { W } * { \boldsymbol { x } } _ { 1 : T } + \mathbf { V } * { \boldsymbol { c } } _ { 1 : T } + b$ , such that the result of the convolution at time $t$ is
+
+$$
+z _ { t } = \sum _ { k = 1 } ^ { K } \mathbf { W } _ { : , : , k } { \pmb x } _ { t - k + 1 } + \sum _ { k = 1 } ^ { K } \mathbf { V } _ { : , : , k } { \pmb c } _ { t - k + 1 } + b .
+$$
+
+Here, $\pmb { \mathsf { W } } \in \mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } \times K }$ and $\pmb { \mathsf { V } } \in \mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { c o n d } } \times K }$ are tensors containing the weights for temporal convolutions of the $C _ { \mathrm { i n } }$ -dimensional input signal $\pmb { x } _ { 1 : T }$ and the $C _ { \mathrm { c o n d } }$ -dimensional conditional signal $c _ { 1 : T }$ with a kernel size of $K$ . Note that the convolutional weights $\boldsymbol { \mathsf { W } }$ and $\pmb { \nu }$ in this formulation are constant over time. Binaural filters in traditional digital signal processing, on the contrary, depend on the position of the sound source.
+
+Inspired by the DSP formulation, we predict the convolutional weights for the input $\pmb { x } _ { 1 : T }$ of a layer and the bias as functions of the conditioning input $c _ { 1 : T }$ ,
+
+$$
+z _ { t } = \sum _ { k = 1 } ^ { K } \left[ \mathcal { H } ^ { ( \mathsf { W } ) } ( c _ { 1 : t } ) \right] _ { : , : , k } x _ { t - k + 1 } + \mathcal { H } ^ { ( b ) } ( c _ { 1 : t } ) .
+$$
+
+This formulation is similar to the use of hyper-networks in Ha et al. (2017) but rather than generating them from intermediate feature maps, weights are generated from the conditioning input $c _ { 1 : T }$ that contains physical information about the relation between source and listener. ${ \mathcal { H } } ^ { ( \bar { \mathbf { w } } ) }$ and $\mathcal { H } ^ { ( b ) }$ are small convolutional hyper-networks that receive $c _ { 1 : t }$ as input and predict the convolutional weights and the bias as their output, respectively. Therefore, not only is the input to the convolutional layer a temporal sequence but the weights and biases change over time as well. We show in Appendix A.3 that if $\mathcal { H } ^ { ( \sf w ) }$ and $\mathcal { H } ^ { ( b ) }$ are linear networks, hyper-convolutions equal equation 5 plus a biliear term.
+
+# 2.3 DEFICIENCIES OF THE $\ell _ { 2 }$ -LOSS ON RAW WAVEFORMS
+
+Training a generative audio model with an $\ell _ { 2 }$ -loss on the raw waveform is generally considered to result in poor audio quality and distorted signals particularly for speech. Therefore, a number of mostly spectrogram oriented alternative loss functions have been introduced over recent years (Kolbæk et al., 2020). Here, we provide an analytical explanation for a fundamental problem of phase estimation with the $\ell _ { 2 }$ -loss on the waveform and show that a simple additional loss term mitigates the problem. While correct phase estimation is not critical for single-channel audio, it is crucial for binaural audio as our ears are sensitive to interaural time differences as small as $1 0 \mu \mathrm { s }$ (Brown & Duda, 1998). To start the analysis, let
+
+$$
+\mathcal { L } _ { 2 } ( y _ { 1 : T } , \hat { y } _ { 1 : T } ) = \sum _ { t } ( y _ { t } - \hat { y } _ { t } ) ^ { 2 }
+$$
+
+be the time-domain $\ell _ { 2 }$ -loss between the predicted audio signal $y _ { 1 : T }$ and the target $\hat { y } _ { 1 : T }$ and let $Y _ { k } , \hat { Y } _ { k } \in \mathbb { C }$ denote the $k$ -th frequency component of $y _ { 1 : t }$ and $\hat { y } _ { 1 : T }$ in the Fourier domain. We denote the amplitude error and angular phase error of the $k$ -th frequency component as
+
+$$
+\begin{array} { r } { \mathcal { L } ^ { ( \mathrm { a m p } ) } ( Y _ { k } , \hat { Y } _ { k } ) = \Big | | Y _ { k } | - | \hat { Y } _ { k } | \Big | \quad \mathrm { a n d } \quad \mathcal { L } ^ { ( \mathrm { p h a s e } ) } ( Y _ { k } , \hat { Y } _ { k } ) = \mathcal { L } ( Y _ { k } , \hat { Y } _ { k } ) , } \end{array}
+$$
+
+where $| \cdot |$ is the modulus (or magnitude) of the complex number.
+
+![](images/7aa7e84a1a2a6519125abc0a6f29b15e7f0e2d6bd23438ff8fc9957169d6350d.jpg)  
+Figure 2: Expected amplitude and phase error from Lemma 1 as a function of $\ell _ { 2 }$ -value $\varepsilon$ and target signal energy $| \hat { Y } |$ .
+
+Lemma 1. Let $\hat { Y } \in \mathbb { C }$ be a fixed complex number and $Y \in \mathbb { B } _ { \varepsilon , \hat { Y } } = \{ Y \in \mathbb { C } : | Y - \hat { Y } | = \varepsilon \}$ be any complex number that has distance $\varepsilon$ from $\hat { Y }$ . Then, the expected amplitude error and the expected angular phase error with respect to $\hat { Y }$ are
+
+$$
+\mathbb { E } _ { Y } \big ( \mathcal { L } ^ { ( \mathrm { a m p } ) } ( Y , \hat { Y } ) \big ) = \frac { 1 } { 2 \pi } | \hat { Y } | \int _ { - \pi } ^ { \pi } \Big | | \frac { \varepsilon } { | \hat { Y } | } + e ^ { i \varphi } | - 1 \Big | d \varphi \qquad \mathrm { a n d }
+$$
+
+$$
+\mathbb { E } _ { Y } \left( \mathcal { L } ^ { ( \mathrm { p h a s e } ) } ( Y , \hat { Y } ) \right) = \frac { 1 } { 2 \pi } \int _ { - \pi } ^ { \pi } \operatorname { a r c c o s } \frac { \mathrm { R e } \left( \frac { \varepsilon } { | \hat { Y } | } e ^ { i \varphi } + 1 \right) } { \left| \frac { \varepsilon } { | \hat { Y } | } + e ^ { i \varphi } \right| } d \varphi .
+$$
+
+Proof. See Appendix A.1.
+
+Using Parseval’s theorem, we write the time-domain $\ell _ { 2 }$ -loss as the $\ell _ { 2 }$ -loss on the complex spectrum,
+
+$$
+\mathcal { L } _ { 2 } ( y _ { 1 : T } , \hat { y } _ { 1 : T } ) = \sum _ { k } | Y _ { k } - \hat { Y } _ { k } | ^ { 2 } .
+$$
+
+Now, consider a single summand from equation 11 and denote the distance $| Y _ { k } - { \hat { Y } } _ { k } |$ as $\varepsilon$ . Lemma 1 allows us to analyze the expected amplitude and phase errors along this $k$ -th frequency component. In Figure 2 we plot equation 9 and equation 10 as a function of the $\ell _ { 2 }$ -value $\varepsilon$ and the target energy $| \hat { Y } |$ . There are two key insights. First, the expected amplitude error is low even for large $\ell _ { 2 }$ -values – that is, in the early stage of training – as long as the target signal has high energy (top right part of Figure 2a). The phase, on the contrary, is barely optimized at all early in training when the $\ell _ { 2 }$ -loss is large, even for high energy components, see Figure 2b. Second, over the course of training, i.e., when the $\ell _ { 2 }$ -loss decreases over time, the expected amplitude error among all target energies decreases. The expected phase error, on the other hand, improves primarily for high energy components and mid- and low energy components tend to have poor phase accuracy even for small $\ell _ { 2 }$ -values.
+
+The above analysis shows that optimizing raw waveforms with a time-domain $\ell _ { 2 }$ -loss leads to a strong focus on fitting the amplitudes but accurate phase reconstruction falls short. Since the models have limited capacity, the training data usually can only be fit up to an $\ell _ { 2 }$ -loss $\varepsilon _ { \mathrm { { m i n } } }$ . If this $\varepsilon _ { \mathrm { { m i n } } }$ is not sufficiently small, the signal’s amplitude can be modeled well but phase errors will always be significant. This can be critical since small amplitude errors lead to a slight change in speech coloration but phase errors introduce perceivable distortions. To overcome the deficiencies of the time-domain $\ell _ { 2 }$ -loss in phase optimization, we add an explicit phase term to the loss function,
+
+$$
+\mathcal { L } ( y _ { 1 : T } , \hat { y } _ { 1 : T } ) = \mathcal { L } _ { 2 } ( y _ { 1 : T } , \hat { y } _ { 1 : T } ) + \lambda \mathcal { L } ^ { ( \mathrm { p h a s e } ) } \big ( \mathrm { S T F T } ( y _ { 1 : T } ) , \mathrm { S T F T } ( \hat { y } _ { 1 : T } ) \big ) ,
+$$
+
+where $\mathrm { S T F T } ( y _ { 1 : T } )$ is the short-term Fourier transform of the audio signal $y _ { 1 : T }$ . 2
+
+![](images/d09cc1b9081a64f9abd58948bc84a2531b1e8313aee435d6ad3f4c2d809bacad.jpg)  
+Figure 3: Development of phase- and amplitude error as the $\ell _ { 2 }$ -loss decreases during training.
+
+Table 1: Comparison of commonly used losses for audio modeling to our proposed $\ell _ { 2 } +$ phase loss.   
+
+<table><tr><td></td><td>raw waveform (lz error ×103)</td><td>power spectrum (l2 error)</td><td>phase spectrum (angular error)</td></tr><tr><td>power spectrum + phase copy</td><td>1.276</td><td>0.048</td><td>1.563</td></tr><tr><td>multiscale STFT</td><td>2.279</td><td>0.043</td><td>1.996</td></tr><tr><td>Si-SDR</td><td>0.798</td><td>0.222</td><td>1.507</td></tr><tr><td>cross entropy on μ-law encoding</td><td>0.161</td><td>0.039</td><td>1.199</td></tr><tr><td>l2</td><td>0.141</td><td>0.037</td><td>0.886</td></tr><tr><td>l2 + phase loss (equation 12)</td><td>0.167</td><td>0.048</td><td>0.807</td></tr></table>
+
+# 3 EVALUATION
+
+Dataset. We recorded a total of 2 hours of paired mono and binaural data at $4 8 \mathrm { k H z }$ from eight different speakers, four male and four female. The listener is a mannequin equipped with binaural microphones in its ears. Participants were asked to walk around the mannequin an a circle with $1 . 5 \mathrm { m }$ radius and have an unscripted conversation with it. We used an OptiTrack system to track position and orientation of source and listener throughout the captures. To the best of our knowledge, this is the only in-the-wild (i.e., not recorded in an anechoic chamber) binaural dataset of such size. We use a validation sequence and the last two minutes from each participant as test data and train the models on the remaining data. See Appendix A.5 for a more detailed description.
+
+Network Architecture. The WarpNet architecture is as described in Section 2.1. The temporal convolutional network consists of three sequential blocks. Each block is a stack of ten hyperconvolution layers with 64 channels, kernel size 2, and the dilation size is doubled after each layer. We train our models for 100 epochs using an Adam optimizer. Learning rates are decreased if between two epochs the loss on the training set did not improve. At inference, our model can produce binaural audio in real-time.
+
+# 3.1 LOSS EVALUATION
+
+In order to empirically validate our findings from Section 2.3, we train our proposed network with time-domain $\ell _ { 2 }$ -loss only and with the loss proposed in equation 12. Figure 3 shows how the phase error and amplitude error develop during training as the time-domain $\ell _ { 2 }$ -loss decreases. The model trained with $\ell _ { 2 }$ -loss only (Figure 3a) shows the behaviour that the analysis in Section 2.3 suggests: the amplitude is optimized aggressively, particularly in the beginning in training when the $\ell _ { 2 }$ -loss is still high. The phase, on the contrary, does hardly improve at all in the beginning and shows only moderate improvements as the $\ell _ { 2 }$ -loss becomes smaller. When training with time-domain $\ell _ { 2 }$ -loss and phase loss (Figure 3b), this effect is being compensated for. The amplitude is optimized less aggressively and phase improves from the beginning of training on.
+
+Various audio losses have been proposed over time, ranging from optimizing the power spectrum only and copying the input’s phase (Zhao et al., 2018; Gao & Grauman, 2019a) over a multiscale STFT loss for high frequency and high time resolution (Yamamoto et al., 2020) to optimization of the scale-invariant signal to distortion ratio (si-SDR, Le Roux et al. (2019); Heitkaemper et al. (2020); Luo & Mesgarani (2019)). With the introduction of WaveNet for speech synthesis (Van Den Oord
+
+Table 2: Ablation study. The components of the proposed binauralization network improve phase and amplitude and thereby the overall loss in time-domain.   
+
+<table><tr><td></td><td></td><td>raw waveform (l2 error ×103)</td><td>power spectrum (l2 error)</td><td>phase spectrum (angular error)</td></tr><tr><td>(a)</td><td>vanilla temporal CNN</td><td>0.254</td><td>0.061</td><td>0.934</td></tr><tr><td>(b)</td><td>+warping</td><td>0.206</td><td>0.061</td><td>0.849</td></tr><tr><td>(c)</td><td>+ hyper-conv</td><td>0.183</td><td>0.051</td><td>0.847</td></tr><tr><td>(d)</td><td>+ sine activation</td><td>0.167</td><td>0.048</td><td>0.807</td></tr></table>
+
+![](images/050e4ebe9bc04fef653e970c0d5043af8da021a949d98f4861c018a3b60a9878.jpg)
+
+(a) Warping example. Top to bottom: source mono input; left ear binaural recording; geometric warping as in equation 2; neural time warping as in equation 4.
+
+![](images/012456a6d534bab3e3e2463ce0055b37fe0d960c6c8b90c5ee188869024d282a.jpg)  
+(b) Amplitude and phase error for different warping schemes, warping plus bilinear amplitude scale, and the full system.   
+Figure 4: Analysis of the warping module.
+
+et al., 2016), interpreting audio optimization as categorical optimization on a $\mu$ -law encoded signal has become a prominent technique. As Table 1 shows, all these approaches fail to predict accurate phase and mostly result in meager power spectral and waveform optimization. Overall, our proposed loss retains accurate $\ell _ { 2 }$ and power spectral estimations while outperforming other criteria by a huge margin in phase error.
+
+Perceptually, we observe a strong correlation between the phase error and noise and distortions in the generated binaural signal. In particular, our proposed loss was the only one that produced clean speech without perceivable distortions. This is consistent with our perceptual study in Table 4, where other approaches with different losses and architectures have been ranked less favorable.
+
+# 3.2 MODEL EVALUATION
+
+Ablation Study. In Table 2, we show the impact of our model’s individual components compared to a vanilla temporal convolutional network baseline with a WaveNet-like architecture and ReLU activations. Number of layers, channels, and kernel sizes are the same as in our final system. Keeping amplitudes unchanged but compensating for interaural time differences, it is not surprising that neural time warping leads to a huge improvement in phase. Replacing regular convolutions with hyper-convolutions, on the contrary, is particularly beneficial to improve the power spectrum. Finally, replacing the ReLU activations by sine functions, which have been proven to retain high frequency details more reliably (Sitzmann et al., 2020), leads to an additional moderate improvement along waveform, phase, and amplitude error.
+
+Neural Time Warping. The purpose of neural time warping is a strong initial alignment of the mono source signal to the left and right ear listener signal, respectively. Note the significant temporal shift between the mono signal and recorded left ear signal in Figure 4a. In the same figure, observe how geometric warping provides an approximate alignment to the reference signal, while the learned neural warping successfully corrects the inaccurate geometric warping and aligns the peaks and valleys more accurately. Although those adjustments seem small, the impact of neural warping on the phase error is significant, as shown in Figure 4b (red bars). Naturally, neural warping can not improve the amplitude (blue bars).
+
+Temporal HyperConv Network. Neural warping provides an accurate alignment between input and target signal. This raises the question if a deep network is required on top of the warping module or if a linear amplitude adjustment can already yield convincing results. We therefore apply a learned bilinear term to the warped result,
+
+![](images/062486a4ba6a60ebd5ce1c2575748f5caf29d119c3d5231101981082fa80df7a.jpg)  
+Figure 5: Training loss of a model with hyper-convolutions and a model with standard convolutions. Hyper-convolutions lead to a significantly faster convergence.
+
+Table 3: Comparison to state of the art approaches for binaural sound synthesis.   
+
+<table><tr><td></td><td>raw waveform (l2 error ×103)</td><td>power spectrum (l2 error)</td><td>phase spectrum (angular error)</td></tr><tr><td>DSP</td><td>0.485</td><td>0.058</td><td>1.388</td></tr><tr><td>2.5D Sound</td><td>1.085</td><td>0.113</td><td>1.519</td></tr><tr><td>WaveNet</td><td>0.237</td><td>0.048</td><td>1.239</td></tr><tr><td>ours</td><td>0.167</td><td>0.048</td><td>0.807</td></tr></table>
+
+Table 4: Mean opinion scores of different approaches. Participants were ask to rank cleanliness, spatialization, and overall realism on a Likert scale from 1 to 5.   
+
+<table><tr><td></td><td>cleanliness</td><td>spatialization</td><td></td><td>realism</td></tr><tr><td>DSP</td><td>3.48 ±0.88</td><td>3.75 ±0.98</td><td>3.62</td><td>±0.90</td></tr><tr><td>2.5D Sound</td><td>2.70 ±1.09</td><td>3.18 ±0.94</td><td>2.70</td><td>±1.03</td></tr><tr><td>WaveNet</td><td>1.20 ±0.51</td><td>2.92 ±1.11</td><td>1.39</td><td>±0.71</td></tr><tr><td>ours</td><td>4.26 ±0.89</td><td>3.76 ±0.91</td><td>3.88</td><td>±0.99</td></tr><tr><td>binaural recordings</td><td>3.69 ±0.94</td><td>3.88 ±0.96</td><td>3.82</td><td>±0.88</td></tr></table>
+
+$$
+y _ { t } ^ { ( l / r ) } = x _ { t } ^ { ( \mathrm { w a r p e d } ) } { \pmb a } ^ { T } { \pmb c } _ { t } + b , \qquad { \pmb a } \in \mathbb { R } ^ { C _ { \mathrm { c o n d } } } , b \in \mathbb { R }
+$$
+
+given the conditioning $\mathbf { } _ { c _ { t } }$ and the warped signal $x ^ { ( \mathrm { w a r p e d } ) }$ for the left or right ear, respectively. Figure 4b shows that this leads to a slight improvement of the amplitude error but falls way behind the performance of the full system with a deep temporal network of hyper-convolutions after the warping module. Inspection of the mono and recorded signal in Figure 4a in fact reveals that the binaural recording undergoes additional transformations beyond warping. Room reverberations, source speech directivity, and modifications caused by the shape of the listener’s ear, for instance, are physical effects that require complex transformations of the warped signal.
+
+Many of these subtle effects depend on the position and orientation of source and listener in the room. It is therefore plausible that conditioned hyper-convolutions, which can model more complex dependencies between inputs and conditioning variables in a single layer, show better performance than standard convolutions, cf. Table 2 (b) versus (c). As Figure 5 reveals, hyper-convolutions also converge significantly faster than standard convolutions in the early stages of training.
+
+# 3.3 STATE OF THE ART COMPARISON
+
+In Table 3, we compare our approach to other neural binauralization approaches and to a DSP baseline, which is the de-facto state of the art for binauralization. The recently proposed 2.5D visual sound (Gao & Grauman, 2019b) network operates in frequency domain and predicts a complex mask which the input is multiplied with to obtain left and right ear outputs. We compare to their approach and replace the visual features with our conditioning features $c _ { 1 : T }$ . For the STFT, we use a window size of 1,600 samples and a hop length of 480 samples (10ms). Therefore, modeling delays of less than 10ms requires non-trivial manipulation of the phase information in the complex spectrogram, which is a more difficult operation than modeling delays in time-domain. We also provide a comparison to a WaveNet that proved to be generally strong in various generative audio problems (Rethage et al., 2018; Engel et al., 2017). For the conditioning on source and listener positions, we follow the approach of Van Den Oord et al. (2016), i.e., the source and listener positions are appended to the input of each temporal convolutional layer. Note that we use the WaveNet in a non-autoregressive setup since the input audio, i.e., the mono signal, is fully available at inference time. Overall, our approach performs significantly better than other methods.
+
+Table 5: Real-time-factor for offline processing and latency for streaming generation of binaural audio. The DSP baseline runs on CPU, all other models run on an NVidia Tesla V100.   
+
+<table><tr><td></td><td>trainableparameters</td><td>offline inference real-time-factor</td><td>streaming mode</td><td>latency</td></tr><tr><td>DSP (* on CPU)</td><td></td><td>0.680</td><td>25.0ms</td><td>(±2.1ms)</td></tr><tr><td>2.5D Sound</td><td>16.7M</td><td>0.013</td><td></td><td></td></tr><tr><td>WaveNet</td><td>1.9M</td><td>0.043</td><td>31.9ms</td><td>(±0.3ms)</td></tr><tr><td>ours</td><td>8.6M</td><td>0.069</td><td>32.8ms</td><td>(±0.4ms)</td></tr></table>
+
+For a perceptual evaluation, we asked 100 participants to rank a total of 2,000 audio snippets from 1 to 5 on a Likert scale according to three criteria: cleanliness of the signal, spatialization quality, and overall realism, see Table 4. All scores are below a 5 (indistinguishable from reality) because participants listened to results for a generic head-related transfer function rather to one that takes their explicit head and ear shape into account. Additionally, user’s headphones are of different quality and not equalized. Note that the binaural (ground truth) recordings score lower on cleanliness because they contain ambient noise that is uncorrelated to the source input and therefore not modeled by our approach. WaveNet leads to a particularly noisy audio signal, which is caused by two major factors. First, audio is generated at $4 8 \mathrm { k H z }$ , which is more difficult to model than $1 6 { - } 2 4 \mathrm { k H z }$ audio. Arik et al. (2017) show that the quality of WaveNet degrades with higher sampling rates. Second, WaveNet has to spend a considerable amount of capacity on modeling large source-to-listener time shifts between the mono and binaural signals and, in consequence, struggles more to generate clean audio. Our approach ranks favorably against other neural binauralization systems and is also preferred in terms of cleanliness and realism over the DSP baseline. A t-test showed that all results in Table 4 are statistically significant with the exception of spatialization between ours and DSP, which is ranked at almost equal quality. Since DSP is the perceptually closest competitor to our approach, we performed an additional perceptual side-by-side study between the two systems that comfirms the results presented in Table 4, see Appendix A.6.
+
+Runtime. When analyzing the runtime of a system, two cases are important. The first is offline processing, where a user provides the complete mono audio to be binauralized in advance. The real-time-factor is the computation time divided by the duration of the input. Table 5 shows that our system allows for a rapid binauralization. On a single NVidia Tesla V100, our approach can binauralize 100 seconds of mono audio in just 6.9 seconds. Note that the DSP baseline does not run on a GPU but is purely CPU-based. The second case is a streaming scenario where binaural audio has to be computed on-the-fly, e.g., when a user navigates through a 3D environment in a game or in virtual reality. In this case, systems are required to have low latency. On an NVidia Tesla V100, our approach runs with roughly $3 3 \mathrm { m s }$ latency, which is low enough to have non-observable delays for videos or games that render frames at $3 0 \mathrm { H z }$ . Note that this is measured with a naive pytorch implementation and allows for several improvements to further lower the latency. The 2.5D sound network can not efficiently be applied in a streaming mode because (a) it is acausal, i.e., requires access to future audio, and (b) it summarizes as much as 0.32 seconds of audio in a single temporal step in its bottleneck layer due to the UNet structure.
+
+# 4 CONCLUSION
+
+Our neural sound binauralization approach is the first purely data-driven end-to-end model that shows convincing performance compared to traditional state of the art binauralization methods. We were able to show effectiveness of our model both quantitatively and in a perceptual user study. Moreover, we unveiled and mitigated a fundamental issue with $\ell _ { 2 }$ -optimization on the raw waveform that affects not only this task but is relevant to other generative audio problems as well.
+
+# REFERENCES
+
+Jont B. Allen and David A. Berkley. Image method for efficiently simulating small-room acoustics. The Journal of the Acoustical Society of America, 65(4):943–950, 1979.
+
+Sercan O Arik, Mike Chrzanowski, Adam Coates, Gregory Diamos, Andrew Gibiansky, Yongguo Kang, Xian Li, John Miller, Andrew $\mathrm { N g }$ , Jonathan Raiman, et al. Deep voice: Real-time neural text-to-speech. Int. Conf. on Machine Learning, 2017.
+
+Cal Armstrong, Lewis Thresh, Damian Murphy, and Gavin Kearney. A perceptual evaluation of individual and non-individual hrtfs: A case study of the sadie ii database. Applied Sciences, 8 (11):2029, 2018.
+
+Futoshi Asano, Yoiti Suzuki, and Toshio Sone. Role of spectral cues in median plane localization. The Journal of the Acoustical Society of America, 88(1):159–168, 1990.
+
+Durand R. Begault, Alexandra S. Lee, Elizabeth M. Wenzel, and Mark R. Anderson. Direct comparison of the impact of head tracking, reverberation, and individualized head-related transfer functions on the spatial perception of a virtual speech source. Journal of the Audio Engineering Society, 2000.
+
+Samuel Bellows and Timothy Leishman. High-resolution analysis of the directivity factor and directivity index functions of human speech. Journal of the Audio Engineering Society, 2019.
+
+Piotr Bilinski, Jens Ahrens, Mark R. P. Thomas, Ivan J. Tashev, and John C. Platt. Hrtf magnitude synthesis via sparse representation of anthropometric features. In IEEE Int. Conf. on Acoustics, Speech and Signal Processing, pp. 4468–4472, 2014.
+
+Fabian Brinkmann, Alexander Lindau, and Stefan Weinzierl. On the authenticity of individual dynamic binaural synthesis. The Journal of the Acoustical Society of America, 142(4):1784–1795, 2017.
+
+C Phillip Brown and Richard O Duda. A structural model for binaural sound synthesis. IEEE transactions on speech and audio processing, 6(5):476–488, 1998.
+
+Corey I. Cheng and Gregory H. Wakefield. Introduction to head-related transfer functions (hrtfs): Representations of hrtfs in time, frequency, and space. Journal of the Audio Engineering Society, 49(4):231–249, 2001.
+
+Hyeong-Seok Choi, Jang-Hyun Kim, Jaesung Huh, Adrian Kim, Jung-Woo Ha, and Kyogu Lee. Phase-aware speech enhancement with deep complex u-net. In Int. Conf. on Learning Representations, 2018.
+
+Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In Int. Conf. on Computer Vision, pp. 764–773, 2017.
+
+Alexandre Defossez, Gabriel Synnaeve, and Yossi Adi. Real time speech enhancement in the waveform domain. In Interspeech, 2020.
+
+James J Deng and Clement HC Leung. Dynamic time warping for music retrieval using time series modeling of musical emotions. IEEE Transactions on Affective Computing, 6(2):137–151, 2015.
+
+Chris Donahue, Julian McAuley, and Miller Puckette. Adversarial audio synthesis. In Int. Conf. on Learning Representations, 2019.
+
+Jesse Engel, Cinjon Resnick, Adam Roberts, Sander Dieleman, Mohammad Norouzi, Douglas Eck, and Karen Simonyan. Neural audio synthesis of musical notes with wavenet autoencoders. In Int. Conf. on Machine Learning, pp. 1068–1077, 2017.
+
+Szu-Wei Fu, Yu Tsao, Xugang Lu, and Hisashi Kawai. Raw waveform-based speech enhancement by fully convolutional networks. In Asia-Pacific Signal and Information Processing Association Annual Summit and Conference, pp. 6–12, 2017.
+
+Ruohan Gao and Kristen Grauman. Co-separating sounds of visual objects. In Int. Conf. on Computer Vision, pp. 3879–3888, 2019a.
+
+Ruohan Gao and Kristen Grauman. 2.5d visual sound. In IEEE Conf. on Computer Vision and Pattern Recognition, 2019b.
+
+Israel D Gebru, Dejan Markovic, Alexander Richard, Steven Krenn, Gladstone Butler, Fernando de la Torre, and Yaser Sheikh. Implicit hrtf modeling using temporal convolutional networks. In IEEE International Conference on Acoustics, Speech and Signal Processing, 2021.
+
+Corentin Guezenoc and Renaud Seguier. Hrtf individualization: A survey. Journal of the Audio Engineering Society, october 2018.
+
+David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. In Int. Conf. on Learning Representations, 2017.
+
+Monica L Hawley, Ruth Y Litovsky, and John F Culling. The benefit of binaural hearing in a cocktail party: Effect of location and type of interferer. The Journal of the Acoustical Society of America, 115(2):833–843, 2004.
+
+Jens Heitkaemper, Darius Jakobeit, Christoph Boeddeker, Lukas Drude, and Reinhold HaebUmbach. Demystifying tasnet: A dissecting approach. In IEEE Int. Conf. on Acoustics, Speech and Signal Processing, pp. 6359–6363, 2020.
+
+Claudia Hendrix and Woodrow Barfield. The sense of presence within auditory virtual environments. Presence: Teleoperators and Virtual Environments, 5(3):290–301, 1996.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015.
+
+Shelton Jose and Kumar Gideon Praveen. Comparison between auditory and visual simple reaction times. Neuroscience & Medicine, 2010, 2010.
+
+B-H Juang. On the hidden markov model and dynamic time warping for speech recognition—a unified view. AT&T Bell Laboratories Technical Journal, 63(7):1213–1243, 1984.
+
+Nal Kalchbrenner, Erich Elsen, Karen Simonyan, Seb Noury, Norman Casagrande, Edward Lockhart, Florian Stimberg, Aaron van den Oord, Sander Dieleman, and Koray Kavukcuoglu. Efficient neural audio synthesis. arXiv preprint arXiv:1802.08435, 2018.
+
+Brian F. G. Katz. Boundary element method calculation of individual head-related transfer function. i. rigid model calculation. The Journal of the Acoustical Society of America, 110(5):2440–2448, 2001.
+
+Paulina Kocon and Brian B. Monson. Horizontal directivity patterns differ between vowels extracted from running speech. The Journal of the Acoustical Society of America, 144(1), 2018.
+
+Morten Kolbæk, Zheng-Hua Tan, Søren Holdt Jensen, and Jesper Jensen. On loss functions for supervised monaural time-domain speech enhancement. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 28:825–838, 2020.
+
+Jonathan Le Roux, Scott Wisdom, Hakan Erdogan, and John R Hershey. Sdr–half-baked or well done? In IEEE Int. Conf. on Acoustics, Speech and Signal Processing, pp. 626–630, 2019.
+
+Song Li and Jurgen Peissig. Measurement of head-related transfer functions: A review. ¨ Applied Sciences, 10(14):5014, 2020.
+
+Yu-Ding Lu, Hsin-Ying Lee, Hung-Yu Tseng, and Ming-Hsuan Yang. Self-supervised audio spatialization with correspondence classifier. In IEEE Int. Conf. on Image Processing, pp. 3347–3351, 2019.
+
+Yi Luo and Nima Mesgarani. Tasnet: time-domain audio separation network for real-time, singlechannel speech separation. In IEEE Int. Conf. on Acoustics, Speech and Signal Processing, pp. 696–700, 2018.
+
+Yi Luo and Nima Mesgarani. Conv-tasnet: Surpassing ideal time–frequency magnitude masking for speech separation. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 27(8): 1256–1266, 2019.
+
+Noam Mor, Lior Wolf, Adam Polyak, and Yaniv Taigman. A universal music translation network. In Int. Conf. on Learning Representations, 2019.
+
+Pedro Morgado, Nuno Nvasconcelos, Timothy Langlois, and Oliver Wang. Self-supervised generation of spatial audio for 360 video. In Advances in Neural Information Processing Systems, pp. 362–372, 2018.
+
+Sebastian Prepelit,a, Michele Geronazzo, Federico Avanzini, and Lauri Savioja. Influence of vox- ˘ elization on finite difference time domain simulations of head-related transfer functions. The Journal of the Acoustical Society of America, 139(5):2489–2504, 2016.
+
+Dario Rethage, Jordi Pons, and Xavier Serra. A wavenet for speech denoising. In IEEE Int. Conf. on Acoustics, Speech and Signal Processing, pp. 5069–5073, 2018.
+
+Atul Rungta, Carl Schissler, Nicholas Rewkowski, Ravish Mehra, and Dinesh Manocha. Diffraction kernels for interactive sound propagation in dynamic environments. IEEE Transactions on Visualization and Computer Graphics, 24(4):1613–1622, 2018.
+
+Lauri Savioja and U. Peter Svensson. Overview of geometrical room acoustic modeling techniques. The Journal of the Acoustical Society of America, 138(2):708–730, 2015.
+
+Lauri Savioja, Jyri Huopaniemi, Tapio Lokki, and Ritta Va¨an¨ anen. Creating interactive virtual ¨ acoustic environments. Journal of the Audio Engineering Society, 47(9):675–705, 1999.
+
+Barbara G. Shinn-Cunningham, Norbert Kopco, and Tara J. Martin. Localizing nearby sound sources in a classroom: Binaural room impulse responses. The Journal of the Acoustical Society of America, 117(5):3100–3115, 2005.
+
+Vincent Sitzmann, Julien NP Martel, Alexander W Bergman, David B Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. arXiv preprint arXiv:2006.09661, 2020.
+
+Kaushik Sunder, Jianjun He, Ee-Leng Tan, and Woon-Seng Gan. Natural sound rendering for headphones: Integration of signal processing techniques. IEEE Signal Processing Magazine, 32(2): 100–113, 2015.
+
+Matthew Tancik, Pratul Srinivasan, Ben Mildenhall, Sara Fridovich-Keil, Nithin Raghavan, Utkarsh Singhal, Ravi Ramamoorthi, Jonathan Barron, and Ren Ng. Fourier features let networks learn high frequency functions in low dimensional domains. Advances in Neural Information Processing Systems, 33, 2020.
+
+Vesa Valim ¨ aki, Julian D. Parker, Lauri Savioja, Julius O. Smith, and Jonathan S. Abel. Fifty years ¨ of artificial reverberation. IEEE Transactions on Audio, Speech, and Language Processing, 20 (5):1421–1448, 2012.
+
+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 ISCA Speech Synthesis Workshop, pp. 125, 2016.
+
+Sean Vasquez and Mike Lewis. Melnet: A generative model for audio in the frequency domain. arXiv preprint arXiv:1906.01083, 2019.
+
+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.
+
+Frederic L. Wightman and Doris J. Kistler. The dominant role of low-frequency interaural time differences in sound localization. The Journal of the Acoustical Society of America, 91(3):1648– 1661, 1992.
+
+Kazuhiko Yamamoto and Takeo Igarashi. Fully perceptual-based 3d spatial sound individualization with an adaptive variational autoencoder. ACM Transaction on Graphics, 36(6), 2017.
+
+Ryuichi Yamamoto, Eunwoo Song, and Jae-Min Kim. Parallel wavegan: A fast waveform generation model based on generative adversarial networks with multi-resolution spectrogram. In IEEE Int. Conf. on Acoustics, Speech and Signal Processing, pp. 6199–6203, 2020.
+
+Karren Yang, Bryan Russell, and Justin Salamon. Telling left from right: Learning spatial correspondence of sight and sound. In IEEE Conf. on Computer Vision and Pattern Recognition, pp. 9932–9941, 2020.
+
+Wen Zhang, Prasanga Samarasinghe, Hanchi Chen, and Thushara Abhayapala. Surround by sound: A review of spatial audio recording and reproduction. Applied Sciences, 7(5):532, 2017.
+
+Hang Zhao, Chuang Gan, Andrew Rouditchenko, Carl Vondrick, Josh McDermott, and Antonio Torralba. The sound of pixels. In European Conf. on Computer Vision, pp. 570–586, 2018.
+
+Hang Zhou, Xudong Xu, Dahua Lin, Xiaogang Wang, and Ziwei Liu. Sep-stereo: Visually guided stereophonic audio generation by associating source separation. In European Conf. on Computer Vision, 2020.
+
+Dmitry N. Zotkin, Ramani Duraiswami, and Larry S. Davis. Rendering localized spatial audio in a virtual auditory space. IEEE Transactions on Multimedia, 6(4):553–564, 2004.
+
+# A APPENDIX
+
+# A.1 PROOF OF LEMMA 1
+
+Before we start with the formal proof, let us get a more intuitive idea what Lemma 1 means and how phase and amplitude error relate to the $\ell _ { 2 }$ -loss in time-domain and complex spectral domain, respectively. Reconsider the $\ell _ { 2 }$ -loss in time-domain and use Parseval’s theorem to relate it to the complex frequency domain,
+
+$$
+\sum _ { t } ( y _ { t } - \hat { y } _ { t } ) ^ { 2 } = \sum _ { k } | Y _ { k } - \hat { Y } _ { k } | ^ { 2 } ,
+$$
+
+where $k$ runs over all frequency components of the signal. The time-domain $\ell _ { 2 }$ -loss is therefore a sum of the $\ell _ { 2 }$ -loss of each individual frequency component in spectral domain. For the analysis, let us consider one fixed frequency component $k$ . Our findings hold for all frequency components equally. Figure 6 illustrates this case in the complex plane.3 Given a target $\hat { Y }$ and a prediction $Y$ that has distance $\varepsilon$ to $\hat { Y }$ , optimizing the $\ell _ { 2 }$ -loss is equal to optimization of the amplitude (the length difference of $Y$ and $\hat { Y }$ ) if $\theta _ { Y } = \theta _ { \hat { Y } }$ . If the phases $\theta _ { Y }$ and $\theta _ { \hat { Y } }$ are different, however, the relation is not that obvious. Lemma 1 makes a statement about the expected amplitude and phase error for a random prediction $Y$ that has $\ell _ { 2 }$ -distance $\varepsilon$ to $\hat { Y }$ , i.e., that lies on the circle defined by $\mathbb { B } _ { \varepsilon , \hat { Y } }$ .
+
+![](images/f2204ea8b5777e709ba74db07183933bd130293762191b649559bf0e2846a72a.jpg)  
+Figure 6: Graphical illustration of the premises for Lemma 1 on the complex plane. $\hat { Y }$ is the target, $Y$ is a prediction with distance $\varepsilon$ to $\hat { Y }$ . The amplitude error is defined as $\left| \left| Y \right| - \left| { \hat { Y } } \right| \right|$ and the phase error is the difference between $\theta _ { Y }$ and $\theta _ { \hat { Y } }$ .
+
+With this in mind, we prove
+
+Lemma 1. Let $\hat { Y } \in \mathbb { C }$ be a fixed complex number and $Y \in \mathbb { B } _ { \varepsilon , \hat { Y } } = \{ Y \in \mathbb { C } : | Y - \hat { Y } | = \varepsilon \}$ be any complex number that has distance $\varepsilon$ from $\hat { Y }$ . Then, the expected amplitude error and the expected
+
+angular phase error with respect to $\hat { Y }$ are
+
+$$
+\begin{array} { r l } { \mathbb { E } _ { Y } \left( \mathcal { L } ^ { ( \mathrm { a m p } ) } ( Y , \hat { Y } ) \right) = \displaystyle \int _ { Y \in \mathbb { B } _ { \varepsilon , \hat { Y } } } \mathcal { L } ^ { ( \mathrm { a m p } ) } ( Y , \hat { Y } ) p ( Y ) d Y } & { \quad } \\ { = \frac { 1 } { 2 \pi } | \hat { Y } | \displaystyle \int _ { - \pi } ^ { \pi } \Big | \big | \frac { \varepsilon } { | \hat { Y } | } + e ^ { i \varphi } \big | - 1 \Big | d \varphi } & { \quad a n d } \end{array}
+$$
+
+$$
+\begin{array} { r } { \mathbb { E } _ { Y } \left( \mathcal { L } ^ { ( \mathrm { p h a s e } ) } ( Y , \hat { Y } ) \right) = \displaystyle \int _ { Y \in \mathbb { B } _ { \varepsilon , \hat { Y } } } \mathcal { L } ^ { ( \mathrm { p h a s e } ) } ( Y , \hat { Y } ) p ( Y ) d Y } \\ { = \displaystyle \frac { 1 } { 2 \pi } \int _ { - \pi } ^ { \pi } \operatorname { a r c c o s } \frac { \mathrm { R e } \left( \frac { \varepsilon } { | \hat { Y } | } e ^ { i \varphi } + 1 \right) } { \left| \frac { \varepsilon } { | \hat { Y } | } + e ^ { i \varphi } \right| } d \varphi . } \end{array}
+$$
+
+Proof. Let $\hat { Y } \in \mathbb { C }$ and $Y \in \mathbb { B } _ { \varepsilon , \hat { Y } }$ . Then, amplitude loss and phase loss as defined in equation 8 are given by
+
+$$
+\begin{array} { r l } & { \mathcal L ^ { ( \mathrm { a m p } ) } ( Y , \hat { Y } ) = \lvert | Y \rvert - \lvert \hat { Y } \rvert | , } \\ & { \mathcal L ^ { ( \mathrm { p h a s e } ) } ( Y , \hat { Y } ) = \angle ( Y , \hat { Y } ) = \mathrm { a r c c o s } \frac { \mathrm { R e } ( Y ) \mathrm { R e } ( \hat { Y } ) + \mathrm { I m } ( Y ) \mathrm { I m } ( \hat { Y } ) } { \lvert Y \rvert \cdot \lvert \hat { Y } \rvert } , } \end{array}
+$$
+
+where $| \cdot |$ denotes the modulus (or magnitude) of a complex number.
+
+Without loss of generality, let $\operatorname { I m } ( { \hat { Y } } ) = 0$ and $\mathrm { R e } ( \hat { Y } ) \geq 0$ . This can always be achieved by a unitary rotation of angle $\theta _ { \hat { Y } }$ around the origin of the complex plane which preserves the lengths and angles between $Y$ and $\hat { Y }$ . In that case, the phase loss simplifies to
+
+$$
+{ \mathcal { L } } ^ { ( \mathrm { p h a s e } ) } ( Y , { \hat { Y } } ) = \operatorname { a r c c o s } { \frac { \mathrm { R e } ( Y ) \cdot | { \hat { Y } } | } { | Y | \cdot | { \hat { Y } } | } } = \operatorname { a r c c o s } { \frac { \mathrm { R e } ( Y ) } { | Y | } } .
+$$
+
+Since $Y \in \mathbb { B } _ { \varepsilon , \hat { Y } }$ is a point on the circle around $\hat { Y }$ with radius $\varepsilon$ (see Figure 6 for an illustration), $\mathbb { B } _ { \varepsilon , \hat { Y } }$ can equivalently be written as
+
+$$
+\mathbb { B } _ { \varepsilon , \hat { Y } } = \{ Y \in \mathbb { C } : Y = \varepsilon \cdot e ^ { i \varphi } + \hat { Y } , \varphi \in [ - \pi , \pi ] \} .
+$$
+
+Then, each $Y \in \mathbb { B } _ { \varepsilon , \hat { Y } }$ is uniquely defined by some $\varphi \in [ - \pi , \pi ]$ and we can rewrite $\mathcal { L } ^ { ( a m p ) }$ as a function of $\varphi$ by substituting $Y = \varepsilon e ^ { i \varphi } + { \hat { Y } }$ ,
+
+$$
+\mathcal { L } _ { \varepsilon , \hat { Y } } ^ { ( \mathrm { a m p } ) } ( \varphi ) = \big | | \varepsilon e ^ { i \varphi } + \hat { Y } | - | \hat { Y } | \big | .
+$$
+
+Observe that due to $\operatorname { I m } ( { \hat { Y } } ) = 0$ and $\mathrm { R e } ( \hat { Y } ) \geq 0$ , it follows that $\mathrm { R e } ( \hat { Y } ) = | \hat { Y } |$ and
+
+$$
+\begin{array} { l } { \displaystyle \big | \varepsilon e ^ { i \varphi } + \hat { Y } \big | = \sqrt { ( \varepsilon \cos \varphi + | \hat { Y } | ) ^ { 2 } + \varepsilon ^ { 2 } \sin ( \varphi ) ^ { 2 } } } \\ { = \vert \hat { Y } \vert \sqrt { \frac { \varepsilon ^ { 2 } } { \vert \hat { Y } \vert ^ { 2 } } + 2 \frac { \varepsilon } { \vert \hat { Y } \vert } \cos \varphi + 1 } } \\ { = \vert \hat { Y } \vert \sqrt { \frac { \varepsilon ^ { 2 } } { \vert \hat { Y } \vert ^ { 2 } } + 2 \frac { \varepsilon } { \vert \hat { Y } \vert } \cos \varphi + \cos ( \varphi ) ^ { 2 } + \sin ( \varphi ) ^ { 2 } } } \\ { = \vert \hat { Y } \vert \cdot \vert \frac { \varepsilon } { \vert \hat { Y } \vert } + e ^ { i \varphi } \vert . } \end{array}
+$$
+
+Therefore,
+
+$$
+\mathcal { L } _ { \varepsilon , \hat { Y } } ^ { ( \mathrm { a m p } ) } ( \varphi ) = | \hat { Y } | \cdot \Big | \big | \frac { \varepsilon } { | \hat { Y } | } + e ^ { i \varphi } \big | - 1 \Big | .
+$$
+
+For the phase error, we apply the same substitution and obtain
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \varepsilon , \hat { Y } } ^ { ( \mathrm { p h a s e } ) } ( \varphi ) = \mathrm { a r c c o s } \frac { \mathrm { R e } ( \varepsilon \varepsilon ^ { i \varphi } + \hat { Y } ) } { | \varepsilon \varepsilon ^ { i \varphi } + \hat { Y } | } } \\ & { \qquad = \mathrm { a r c c o s } \frac { | \hat { Y } | \left( \frac { \varepsilon } { \sqrt { Y } } \right) \cos \varphi + 1 } { | \hat { Y } | \cdot \left| \frac { \varepsilon } { | \sqrt { Y } | } + \varepsilon ^ { i \varphi } \right| } } \\ & { \qquad = \mathrm { a r c c o s } \frac { \frac { \hat { \varepsilon } } { \sqrt { Y } } \cos \varphi + 1 } { \left| \frac { \hat { \varepsilon } } { | \hat { Y } | } + \varepsilon ^ { i \varphi } \right| } } \\ & { \qquad = \mathrm { a r c c o s } \frac { \mathrm { R e } \left( \frac { \varepsilon } { | \hat { \varepsilon } | } \varphi + \varepsilon \right) } { \left| \frac { \varepsilon } { | \hat { \varepsilon } | } + \varepsilon ^ { i \varphi } \right| } . } \end{array}
+$$
+
+The expected amplitude and phase error can now be written as
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { \varphi } ( \mathcal { L } _ { \varepsilon , \hat { Y } } ^ { ( \mathrm { a m p } ) } ( \varphi ) ) = \displaystyle \int _ { - \pi } ^ { \pi } \mathcal { L } _ { \varepsilon , \hat { Y } } ^ { ( \mathrm { a m p } ) } ( \varphi ) p ( \varphi ) d \varphi \qquad \mathrm { a n d } } \\ & { \mathbb { E } _ { \varphi } ( \mathcal { L } _ { \varepsilon , \hat { Y } } ^ { ( \mathrm { p h a s e } ) } ( \varphi ) ) = \displaystyle \int _ { - \pi } ^ { \pi } \mathcal { L } _ { \varepsilon , \hat { Y } } ^ { ( \mathrm { p h a s e } ) } ( \varphi ) p ( \varphi ) d \varphi . } \end{array}
+$$
+
+Assuming that $Y \in \mathbb { B } _ { \varepsilon , \hat { Y } }$ is uniformly distributed on the circle around $\hat { Y }$ , i.e., $p ( \varphi )$ follows a circular uniform distribution, we have $\textstyle p ( \varphi ) = { \frac { 1 } { 2 \pi } }$ and plug in equation 23 and equation 24 to obtain the claim from Lemma 1. □
+
+# A.2 FREQUENCY-DOMAIN LOSS FORMULATION
+
+In our original formulation of the phase-enhanced loss in equation 12, phase is technically penalized twice: once implicitly in the $\ell _ { 2 }$ -loss on the raw waveform and once explicitly in the phase loss term. It is possible to formulate the phase-enhanced loss in frequency domain such that there is a clear separation of magnitude and phase loss in two different additive terms.
+
+Due to Parseval’s theorem, optimizing the $\ell _ { 2 }$ -loss in time domain is equivalent to optimizing the $\ell _ { 2 }$ -loss in frequency domain. We transform the time domain audio signal into frequency domain using a short-term Fourier transform and denote the result of the transformation as
+
+$$
+Y _ { 1 : K , 1 : S } = \mathrm { S T F T } ( y _ { 1 : T } ) ,
+$$
+
+where $K$ is the number of frequency bins of the discrete Fourier transform and $S$ is the number of STFT steps, i.e., $S \ : = \ : T /$ hop length. Since the frequency spectrum can be expressed by it’s magnitude and phase spectrum, we can reformulate equation 12 as
+
+$$
+\mathcal { L } ( y _ { 1 : T } , \hat { y } _ { 1 : T } ) = \sum _ { k , s } \left[ \mathcal { L } ^ { ( \mathrm { a m p } ) } ( Y _ { k , s } , \hat { Y } _ { k , s } ) + \lambda \mathcal { L } ^ { ( \mathrm { p h a s e } ) } ( Y _ { k , s } , \hat { Y } _ { k , s } ) \right] .
+$$
+
+Note that this form is not equivalent to the original loss since separating the frequency spectrum into magnitude and phase is a non-unitary operation. However, we do not find the differences to be significant, as Table 6 shows. In fact, the clear separation allows for a better adjustment of the phase weight $\lambda$ and can even lead to slightly improved results.
+
+# A.3 INTERPRETATION OF HYPER-CONVOLUTIONS
+
+Hyper-convolutions are a generalization of stardard convolutions as long as $\mathcal { H } ^ { ( \sf w ) }$ and $\mathcal { H } ^ { ( b ) }$ are able to learn a linear transformation. Specifically, if $\mathcal { H } ^ { ( \sf W ) }$ and $\mathcal { H } ^ { ( b ) }$ are linear convolutional networks, hyper-convolutions extend equation 5 by a bilinear term. We show this property in the following and provide an example for a simple fully connected layer.
+
+Recall the definition of hyper-convolutions from equation 6,
+
+$$
+z _ { t } = \sum _ { k = 1 } ^ { K } \left[ \mathcal { H } ^ { ( \mathsf { W } ) } ( c _ { 1 : t } ) \right] _ { : , : , k } x _ { t - k + 1 } + \mathcal { H } ^ { ( b ) } ( c _ { 1 : t } ) .
+$$
+
+Table 6: Comparison of the loss formulation from equation 12 and equation 28. While the first penalizes phase twice, once implicitly in the time-domain $\ell _ { 2 }$ -loss and once in the explicit phase loss term, the latter provides a clear separation between magnitude and phase loss terms.   
+
+<table><tr><td></td><td>raw waveform (l2 error ×103)</td><td>power spectrum (l2 error)</td><td>phase spectrum (angular error)</td></tr><tr><td>loss from equation 12</td><td>0.167</td><td>0.048</td><td>0.807</td></tr><tr><td>loss from equation 28</td><td>0.157</td><td>0.036</td><td>0.809</td></tr></table>
+
+Lemma 2. Let $\mathcal { H } ^ { ( \sf w ) }$ and $\mathcal { H } ^ { ( b ) }$ be linear convolutional networks with kernel size $K$ . Let further $\pmb { x } _ { 1 : T }$ and $c _ { 1 : T }$ be a sequence of input and conditional vectors in $\mathbb { R } ^ { C _ { i n } }$ and $\mathbb { R } ^ { C _ { c o n d } }$ , and the output $z _ { 1 : T }$ be a sequence of vectors in $\mathbb { R } ^ { C _ { o u t } }$ . Then, the hyper-convolution from equation 29 reduces to
+
+$$
+\begin{array} { r } { { \displaystyle z _ { t } = \sum _ { k = 1 } ^ { K } \sum _ { k ^ { \prime } = 1 } ^ { K } \sum _ { j = 1 } ^ { C _ { i n } } x _ { t - k + 1 , j } \cdot \mathbf { U } _ { : , j , k , : , k ^ { \prime } } c _ { t - k ^ { \prime } + 1 } } } \\ { { \displaystyle + \sum _ { k = 1 } ^ { K } \mathbf { W } _ { : , : , k } \mathbf { x } _ { t - k + 1 : t } + \sum _ { k = 1 } ^ { K } \mathbf { V } _ { : , : , k } c _ { t - k + 1 } + b } } \end{array}
+$$
+
+with $\mathbf { U } \in \mathbb { R } ^ { ( C _ { o u t } \times C _ { i n } \times K ) \times ( C _ { c o n d } \times K ) }$ , $\pmb { \mathsf { W } } \in \mathbb { R } ^ { C _ { o u t } \times C _ { i n } \times K }$ , $\pmb { \mathsf { V } } \in \mathbb { R } ^ { C _ { o u t } \times C _ { c o n d } \times K }$ and $\pmb { b } \in \mathbb { R } ^ { C _ { o u t } }$ .
+
+Proof. We start from equation 29 and use that both $\mathcal { H } ^ { ( \sf W ) }$ and $\mathcal { H } ^ { ( b ) }$ are linear (and therefore, w.l.o.g. single-layer) convolutional networks with kernel size $K$ , such that
+
+$$
+z _ { t } = \sum _ { k = 1 } ^ { K } { \left[ \mathcal { H } ^ { ( \mathbf { W } ) } ( c _ { t - K + 1 : t } ) \right] } _ { : , : , k } x _ { t - k + 1 } + \mathcal { H } ^ { ( b ) } ( c _ { t - K + 1 : t } ) .
+$$
+
+First, consider $\mathcal { H } ^ { ( b ) } : \mathbb { R } ^ { C _ { \mathrm { c o n d } } \times K } \mapsto \mathbb { R } ^ { C _ { \mathrm { o u t } } }$ . Since $\mathcal { H } ^ { ( b ) }$ is linear, it can be written as
+
+$$
+{ \mathcal { H } } ^ { ( b ) } ( { \pmb { c } } _ { t - K + 1 : t } ) = \sum _ { k = 1 } ^ { K } { \pmb { \vee } } _ { : , : , k } { \pmb { c } } _ { t - k + 1 } + b
+$$
+
+with $\pmb { \mathsf { V } } \in \mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { c o n d } } \times K }$ and $\pmb { b } \in \mathbb { R } ^ { C _ { \mathrm { o u t } } }$ . Note that this already yields the last two terms in equation 30. While $\mathcal { H } ^ { ( b ) }$ only generates a bias, $\mathcal { H } ^ { ( \sf W ) }$ needs to generate a $\mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } \times K }$ sized tensor to realize the convolution with ${ \pmb x } _ { 1 : T }$ . Thus, $\mathcal { H } ^ { ( \mathsf { W } ) } : \mathbb { R } ^ { C _ { \mathrm { { c o n d } } } \times K } \overset { = } \mapsto \mathbb { R } ^ { C _ { \mathrm { { o u t } } } \times C _ { \mathrm { { i n } } } \times K }$ and due to $\mathcal { H } ^ { ( \sf w ) }$ being a linear function, the component at $( i , j , k )$ of the output tensor is given as
+
+$$
+\left[ \mathcal { H } ^ { ( \mathbf { W } ) } ( c _ { t - K + 1 : t } ) \right] _ { i , j , k } = \sum _ { k ^ { \prime } = 1 } ^ { K } \mathbf { U } _ { i , j , k , : , k ^ { \prime } } c _ { t - k ^ { \prime } + 1 } + \mathbf { W } _ { i , j , k } ,
+$$
+
+where $\mathbf { U } ~ \in ~ \mathbb { R } ^ { ( C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } \times K ) \times ( C _ { \mathrm { c o n d } } \times K ) }$ is the weight tensor of the hypernetwork $\mathcal { H } ^ { ( \sf W ) }$ and $\textsf { \textbf { W } } \in$ $\mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } \times K }$ is its bias. For simplicity of notation, let $\hat { z } _ { t }$ be ${ \boldsymbol { z } } _ { t }$ from equation 31 without $\mathcal { H } ^ { ( b ) } ( c _ { t - K + 1 : t } )$ . Using equation 33, $\hat { z } _ { t }$ is then given by
+
+$$
+\begin{array} { l } { \displaystyle \hat { z } _ { t } = \sum _ { k = 1 } ^ { K } \sum _ { j = 1 } ^ { C _ { \mathrm { i n } } } { \left[ \mathcal { H } ^ { ( \mathsf { W } ) } ( c _ { t - K + 1 : t } ) \right] _ { : , j , k } } \cdot x _ { t - k + 1 , j } } \\ { = \displaystyle \sum _ { k = 1 } ^ { K } \sum _ { j = 1 } ^ { C _ { \mathrm { i n } } } { \left[ \sum _ { k ^ { \prime } = 1 } ^ { K } \mathbf { U } _ { : , j , k , : , k ^ { \prime } } c _ { t - k ^ { \prime } + 1 } + \mathbf { W } _ { : , j , k } \right] } \cdot x _ { t - k + 1 , j } } \\ { = \displaystyle \sum _ { k = 1 } ^ { K } { \sum _ { k ^ { \prime } = 1 } ^ { K } \sum _ { j = 1 } ^ { C _ { \mathrm { i n } } } { x _ { t - k + 1 , j } } \cdot \mathbf { U } _ { : , j , k , : , k ^ { \prime } } c _ { t - k ^ { \prime } + 1 } } + \sum _ { k = 1 } ^ { K } \mathbf { W } _ { : , : , k } x _ { t - k + 1 : t } . } \end{array}
+$$
+
+Together with equation 32, this yields the claim from Lemma 2,
+
+$$
+\begin{array} { r l } & { z _ { t } = \hat { z } _ { t } + \mathcal { H } ^ { ( b ) } ( c _ { t - K + 1 : t } ) } \\ & { \quad = \displaystyle \sum _ { k = 1 } ^ { K } \sum _ { k ^ { \prime } = 1 } ^ { K } \sum _ { j = 1 } ^ { C _ { \mathrm { i n } } } x _ { t - k + 1 , j } \cdot \mathbf { U } _ { : , j , k , : , k ^ { \prime } } c _ { t - k ^ { \prime } + 1 } } \\ & { \quad \quad + \displaystyle \sum _ { k = 1 } ^ { K } \mathbf { W } _ { : , : , k } \mathbf { x } _ { t - k + 1 : t } + \displaystyle \sum _ { k = 1 } ^ { K } \mathbf { V } _ { : , : , k } c _ { t - k + 1 } + b . } \end{array}
+$$
+
+The last row of equation 35 is exactly the definition of a standard conditioned temporal convolution from equation 5. The row before is a bilinear combination of $c _ { 1 : T }$ and $\pmb { x } _ { 1 : T }$ . As a consequence of Lemma 2, conditioned (linear) hyper-convolutions are therefore a strict generalization of the standard conditioned temporal convolutions from equation 5. Note that any non-linear $\mathcal { H } ^ { ( \sf W ) }$ and $\mathcal { H } ^ { ( b ) }$ that is capable of learning a linear transformation is therefore also a strict generalization of equation 5.
+
+Example: $K = 1 , C _ { \mathrm { o u t } } = 1$ .
+
+We illustrate the case for $K = 1$ , i.e., the convolutions break down to a simple fully connected layer.   
+To simplify notation, we also restrict this example to a single output channel $C _ { \mathrm { o u t } } = 1$ .
+
+With linear hyper-convoltions and $C _ { \mathrm { o u t } } = 1$ , we have
+
+$$
+\mathcal { H } ^ { ( \mathsf { W } ) } ( \pmb { c } _ { t } ) = \pmb { U } \pmb { c } _ { t } + \pmb { w } , \qquad \mathcal { H } ^ { ( b ) } ( \pmb { c } _ { t } ) = \pmb { v } ^ { T } \pmb { c } _ { t } + b
+$$
+
+for a weight matrix $U \in \mathbb { R } ^ { C _ { \mathrm { i n } } \times C _ { \mathrm { c o n d } } }$ and a bias vector $\boldsymbol { w } \in \mathbb { R } ^ { C _ { \mathrm { i n } } }$ as parameters of $\mathcal { H } ^ { ( \sf W ) }$ as well as weights $\pmb { v } \in \mathbb { R } ^ { C _ { \mathrm { c o n d } } }$ and bias $b \in \mathbb { R }$ as parameters for $\mathcal { H } ^ { ( b ) }$ . Inserting this into equation 29 leads to
+
+$$
+\begin{array} { r l } & { z _ { t } = \mathcal { H } ^ { ( \mathsf { W } ) } ( c _ { t } ) \pmb { x } _ { t } + \mathcal { H } ^ { ( b ) } ( c _ { t } ) } \\ & { \quad = ( U \pmb { c } _ { t } + \pmb { w } ) ^ { T } \pmb { x } _ { t } + \pmb { v } ^ { T } \pmb { c } _ { t } + b } \\ & { \quad = \pmb { x } _ { t } ^ { T } U \pmb { c } _ { t } + \pmb { w } ^ { T } \pmb { x } _ { t } + \pmb { v } ^ { T } \pmb { c } _ { t } + b . } \end{array}
+$$
+
+Compared to the standard formulation from equation 5,
+
+$$
+z _ { t } = \pmb { w } ^ { T } \pmb { x } _ { t } + \pmb { v } ^ { T } \pmb { c } _ { t } + b ,
+$$
+
+equation 37 adds the bilinear term $\pmb { x } _ { t } ^ { T } \pmb { U } \pmb { c } _ { t }$ while all other terms are still remaining.
+
+# A.4 SIGNAL PROCESSING BASELINE
+
+Sound produced in a scene arrives at the left and right ear at offset times due to the marginal difference in their distance from the source of sound (Wightman & Kistler, 1992). The coronal (back/front) asymmetry of the outer ear (pinnae) further transforms the incoming sound wave differently depending on the direction of the source (Asano et al., 1990; Cheng & Wakefield, 2001). Room effects such reverberation influence auditory localization as well (Shinn-Cunningham et al., 2005). These binaural disparities allow listeners to localize sources of sound in three dimensions (Begault et al., 2000) and gain a more complete sense of the state of the space around them.
+
+Traditionally different effects that influence propagation between the source and the listener, i.e., different components of the mapping function between the input mono signal and output binaural signals, are addressed separately. The components are assumed to be linear time-invariant (LTI) systems and therefore completely characterized by their impulse responses. They are then combined to produce the output signals with a series of convolution operations (Savioja et al., 1999; Zotkin et al., 2004; Sunder et al., 2015; Zhang et al., 2017). A short overview follows.
+
+Source. People are not omnidirectional sound sources and, unlike a loudspeaker whose spatial directivity depends only on the frequency, the human directivity pattern may depend on speech content and pose as well. Though some studies of speech directivity in controlled settings exist (Kocon &
+
+Monson, 2018; Bellows & Leishman, 2019), in practical applications it is either ignored or approximated with a simple pattern such as a cardioid.
+
+Environment: room acoustics. The reverberation is caused by the interaction of the sound field with the surrounding environment. Different approaches to room acoustic modeling exist but they are mainly divided in two groups (Valim ¨ aki et al., 2012): (1) physically accurate but computationally ¨ expensive wave-based methods that, given detailed geometry and material information, numerically solve the wave equation; and (2) methods based on geometrical acoustics (Savioja & Svensson, 2015) that ignore the wave nature of sound and assume a ray-like behaviour, and are therefore more suitable for real-time operation (wave phenomena such as diffraction is usually modeled separately (Rungta et al., 2018)). For the real-world rooms the room impulse responses (RIRs) are either measured or computed using simplified geometric models informed by some estimated room parameters. It is important to note that measurement procedure is infeasible for fully dynamic scenarios since RIRs depend on both source and listener spatial positions. The length of the RIR filters depends on the reverberation time of the environment, i.e., the time it takes for sound to decay by 60dB, which can go from less than half a second for typical office spaces to a couple of seconds for auditoriums and concert halls, and around ten seconds for large cathedrals.
+
+Environment: background noise. Even in absence of other interfering sound sources, there is always some degree of ambient noise present in the environment. Usually this noise is assumed to be diffuse and independent from the listener position. It is also often assumed to be stationary and it can be estimated from short silence intervals.
+
+Listener. The human body, most notably pinna, head and torso, modify the incoming acoustic waves in a way that is crucial for the spatial perception of sound. Traditionally the head-related transfer function (HRTF) is used to model these effects (Cheng & Wakefield, 2001). In theory, the HRTF is personalized to the individual (listener) and depends on the source position relative to the listener. However, most practical implementations use a generic (not-personalized) HRTF though HRTF penalization is an active research area (Bilinski et al., 2014; Yamamoto & Igarashi, 2017; Guezenoc & Seguier, 2018). Moreover, measuring HRTF in a volume is impractical and it is usually measured on a fixed radius (Li & Peissig, 2020), making the HRTF a function of the source direction only. In alternative, the boundary element method (BEM) (Katz, 2001) or finite-difference time-domain (FDTD) method (Prepelit,a et al., 2016) can be used for numerical HRTF simulation ˘ using head and torso scans. Depending on the dataset, the HRTF filters are usually $2 . 5 - 2 0 \mathrm { { m s } }$ long after removing the initial onset delays.
+
+Equipment. While above components are enough to model the physics involved in the mapping between the input and the output signals, in a practical setting the capture/reproduction equipment plays a role as well. To compensate for the frequency response of the equipment and the signalprocessing chain, the equalization filter should be applied. It is often assumed that this filter does not change in time and it can be estimated from a test capture.
+
+Note that each of above steps introduces some degree of estimation, measurement or modeling errors that accumulate down the pipeline and, not being formulated in an end-to-end fashion, the solution is sub-optimal from the perspective of the particular application. Furthermore, a study showed that even using binaural room impulse responses measured for the test subject inside the test environment, the perceptual authenticity between virtual and real sound sources was not fully achieved for a dynamic scenario that allowed natural head movements of the listeners (Brinkmann et al., 2017).
+
+Our implementation, used as the DSP baseline, computes the output binaural signals ${ \boldsymbol y } ^ { ( l / r ) } ( t )$ , for left and right ear respectively, from the input mono signal $x ( t )$ , $t$ being the sample index, as follows:
+
+$$
+y ^ { ( l / r ) } ( t ) = h _ { \mathrm { e q } } ^ { ( l / r ) } ( t ) * h _ { \mathrm { h r t f } } ^ { ( l / r ) } ( t , \theta _ { t } ^ { \mathrm { ( s r c , l s i n ) } } ) * h _ { \mathrm { r i r } } ( t , \theta _ { t } ^ { \mathrm { ( s r c ) } } , p _ { t } ^ { \mathrm { ( s r c ) } } , p _ { t } ^ { \mathrm { ( l s u ) } } ) * x ( t ) + w ^ { ( l / r ) } ( t ) ,
+$$
+
+where
+
+• $x ( t )$ is assumed to be a clean input signal; $^ *$ indicates the convolution operation;
+
+$h _ { \mathrm { r i r } } ( t , \pmb { \theta } _ { t } ^ { \mathrm { ( s r c ) } } , \pmb { p } _ { t } ^ { \mathrm { ( s r c ) } } , \pmb { p } _ { t } ^ { \mathrm { ( l s t n ) } } )$ is the RIR computed using the image source method (Allen & Berkley, 1979) assuming a simple rectangular room and reverberation time 0.2s; $\mathbf { \nabla } _ { \mathbf { \mathcal { P } } _ { t } ^ { \mathrm { ( s r c ) } } }$ and ${ \pmb p } _ { t } ^ { ( \mathrm { l s t n } ) }$ are the source and listener positions, and $\pmb { \theta } _ { t } ^ { \mathrm { ( s r c ) } }$ indicates the source orientation used to simulate cardioid directivity;
+
+$h _ { \mathrm { h r t f } } ^ { ( l / r ) } ( t , \pmb { \theta } _ { t } ^ { \mathrm { ( s r c , l s t n ) } } )$ is the head related impulse response (HRTF in the time-domain) for the left $/$ right ear; the HRTF of a KEMAR mannequin, measured in an anechoic chamber at 9600 unique discrete positions on a sphere of radius $2 \mathrm { m }$ is used; $\pmb { \theta } _ { t } ^ { \mathrm { ( s r c , l s t n ) } }$ indicates the direction on which the source is found with respect to the listener’s front; • $h _ { \mathrm { e q } } ^ { ( l / r ) } ( t )$ is the equalization filter for the given channel, estimated from a test capture in • $w ^ { ( l / r ) } ( t )$ is the random noise added to the given channel, generated with a power spectral density estimated from a test capture during a silence period.
+
+Since the filters depend on source and listener positions, which in a dynamic scenario are continuously changing, the computation is done on a frame-by-frame basis using the overlap-add method, with frame length of 1024 samples and $7 5 \%$ overlap (at sampling rate of $4 8 \mathrm { k H z }$ ).
+
+# A.5 DATASET DESCRIPTION
+
+Dataset Overview. We recorded eight different subjects, four male and four female, in an acoustically treated room. The capture contains unidirectional conversational speech, i.e., we asked participants to talk to a mannequin for 15 minutes each while walking around. We collected approximately 2 hours of mono-to-binaural audio data in total. Source and listener head positions are tracked and synchronized with the recorded audio. We use the last two minutes from each subject and a separately recorded validation sequence as test data and kept the remaining data as training data. To the best of our knowledge, this is the first binaural data capture of its kind, i.e., modeling moving trajectories between receiver and transmitter position and recorded in a regular room rather than an anechoic chamber.
+
+Data Capture Details. The acoustic head and torso simulator is the GRAS KEMAR mannequin with the size large anthropometric pinnae inserts. Participants were free to walk around a $1 . 5 \mathrm { m }$ radius circle around the KEMAR mannequin, and prompted to cover as much area as a normal social conversation would. The KEMAR mannequin was wearing a B&K 4101B binaural microphone headset. The subjects wore a DPA 4060-OC microphone taped next to their mouth to capture their speech. The participants wore a modified bicycle helmet with reflective markers for head-pose tracking using an OptiTrack system. Although the KEMAR mannequin did not move, KEMAR wore a headband with reflective markers for head-pose tracking for complete source/listener headpose tracking. All tracking information was captured with a field array of 24 OptiTrack Prime 17W cameras. The audio data is recorded at $4 8 \mathrm { k H z }$ sampling rate and rigid body tracking data is collected at 120fps via motion capture software, Motive. LTC signal is used to synchronize the audio recordings with OptiTrack data. The capture layout is schematically illustrated in Figure 7.
+
+# A.6 EXTENDED EVALUATION
+
+Additional Perceptual Evaluation. In order to back the results of the perceptual study in Table 4, we performed a side-by-side evaluation of our system and the DSP baseline, which was ranked to be the strongest competitor to our approach. In this study, participants were presented an audio snipped rendered with DSP and the same snippet rendered with our approach. The snippets are presented side-by-side in random order to ensure an unbiased evaluation. Participants were then asked to decide which of the two methods is preferable in terms of cleanliness, spatialization, and realism. We additionally gave participants the option to select can not tell the difference as an answer. Overall, 30 participants evaluated 360 binaural snippets generated with DSP and our method, respectively. The results in Table 7 support our findings from Table 4: our approach is preferred in terms of cleanliness and realism. For spatialization, most participants could not find a clear favorite, which is consistent with the mean opinion score of 3.75 vs. 3.76 that is reported in Table 4.
+
+Unseen Subjects. While previous evaluations were based on unseen audio data from speakers that are part of the training set, we evaluate the performance on unseen speakers here. We train our model in a leave-one-speaker-out setup, i.e., we train eight models, each with another speaker being held out. Table 8 shows that our approach still outperforms the DSP baseline by a large margin on unseen subjects. This is remarkable, considering that only seven different subjects are seen during training. With a more diverse dataset, we expect the generalization quality of our approach to increase significantly.
+
+![](images/5e2bf7f5a3fe331ebf97320cd505b02550ec7247b549b13f8190d7ab8b612c0d.jpg)  
+Figure 7: (a) Side view of capture layout. (b) Top view of capture layout. A participant moves around a KEMAR mannequin within the boundaries of a marked circle. The participant speech is recorded with a head mounted microphone and the binaural audio is captured with binaural microphones on the ears of the mannequin. Mannequin and participant positions are tracked with OptiTrack cameras mounted on the walls of the room.
+
+Table 7: Side-by-side study of DSP vs. our system. Participants were presented two clips, one generated with DSP, one with our approach, and were then asked to tell which one they prefer.   
+
+<table><tr><td></td><td>DSP preferred</td><td>ours preferred</td><td>can not tell the difference</td></tr><tr><td>cleanliness</td><td>1.8%</td><td>88.9%</td><td>9.3%</td></tr><tr><td>spatialization</td><td>25.9%</td><td>27.7%</td><td>46.4%</td></tr><tr><td>realism</td><td>31.5%</td><td>53.7%</td><td>14.8%</td></tr></table>
+
+Activation Functions. In recent works (Sitzmann et al., 2020; Tancik et al., 2020), sine activations have been found to preserve high frequency information better than other commonly used activation functions if weights are initialized appropriately. As reconstructing high frequencies is particularly important for audio modeling, we adopt this strategy in our network. Table 9 shows a comparison of our network with ReLUs, gated convolutions as used in Van Den Oord et al. (2016), and sine activations as used in Sitzmann et al. (2020). ReLUs do not perform well on audio data: their sparse outputs are not well suited to model the smooth and sinusoid nature of waveforms. For this reason, WaveNet originally used gated convolutions, which we also find to work better than ReLUs in our task. Overall, however, we still find sine activations to produce the best results.
+
+Qualitative Results. We show qualitative results on the raw waveform in Figure 8. Note the considerable temporal shift between the mono signal captured at the source’s microphone and the binaural recording. A strong binauralization system is required to accurately model not only this temporal shift but also produce a metrically correct waveform, i.e., match the shape of the binaural recording’s waveform. When comparing the results for WaveNet and the 2.5D Sound architecture, it is apparent that both approaches lack in their ability to accurately match the recording’s waveform.
+
+Table 8: Generalization to unseen subjects. In a leave-on-subject-out setup, our approach still outperforms the DSP baseline by a significant margin.   
+
+<table><tr><td></td><td>raw waveform (l2 error ×103)</td><td>power spectrum (l2 error)</td><td>phase spectrum (angular error)</td></tr><tr><td>DSP</td><td>0.485</td><td>0.058</td><td>1.388</td></tr><tr><td>ours (unseen subjects)</td><td>0.265</td><td>0.058</td><td>1.099</td></tr></table>
+
+Table 9: Effect of the activation function used in the temporal hyper-convolutions.   
+
+<table><tr><td></td><td>raw waveform (l2 error ×103)</td><td>power spectrum (l2 error)</td><td>phase spectrum (angular error)</td></tr><tr><td>ours with ReLU</td><td>0.183</td><td>0.051</td><td>0.847</td></tr><tr><td>ours with gated convolutions</td><td>0.179</td><td>0.053</td><td>0.819</td></tr><tr><td>ours with sine activation</td><td>0.167</td><td>0.048</td><td>0.807</td></tr></table>
+
+![](images/368f92399aa5a2bc156968fd2538d06d45ffd9ebf96f7ab02930ca4cc25db7e6.jpg)![](images/44534a0ba52956810bc9da46da06e8bb34d204534f58141321504680a1767257.jpg)  
+Figure 8: Qualitative results on the raw waveform. Note that 2.5D visual sound – besides having an overall inaccurate waveform reconstruction – fails to get an accurate alignment to the binaural recording. Compared to all state of the art, our approach matches the real binaural recordings best.
+
+Additionally, the 2.5D sound approach fails to align its output to the recordings. This comes of no surprise as the model is inherently designed to solve an upmixing problem, i.e., a problem where temporal shifts do not exist. Also note that due to $\mu$ -law quantization that is typically applied in WaveNet, its results are non-smooth and introduce high-frequency noise due to quantization bins being misclassified. The DSP approach, which is to day the de-facto state of the art, performs more favorably in terms of temporal alignment and overall matching of the recording’s waveform. Compared to our approach, however, there are significant inaccuracies – an observation that is consistent with our evaluation in Section 3.3.