Add files using upload-large-folder tool

parse/train/H1xk8jAqKQ/H1xk8jAqKQ.md

@@ -0,0 +1,398 @@
+# BACKPLAY: ‘MAN MUSS IMMER UMKEHREN’
+
+Cinjon Resnick∗ NYU cinjon@nyu.edu
+
+Roberta Raileanu∗ NYU rr3009@nyu.edu
+
+Sanyam Kapoor NYU sanyam@nyu.edu
+
+Alexander Peysakhovich FAIR alexpeys@fb.com
+
+Kyunghyun Cho   
+NYU, FAIR   
+kyunghyun.cho@nyu.edu   
+Joan Bruna   
+NYU, FAIR   
+bruna@cims.nyu.edu
+
+# ABSTRACT
+
+Model-free reinforcement learning (RL) requires a large number of trials to learn a good policy, especially in environments with sparse rewards. We explore a method to improve the sample efficiency when we have access to demonstrations. Our approach, Backplay, uses a single demonstration to construct a curriculum for a given task. Rather than starting each training episode in the environment’s fixed initial state, we start the agent near the end of the demonstration and move the starting point backwards during the course of training until we reach the initial state. Our contributions are that we analytically characterize the types of environments where Backplay can improve training speed, demonstrate the effectiveness of Backplay both in large grid worlds and a complex four player zero-sum game (Pommerman), and show that Backplay compares favorably to other competitive methods known to improve sample efficiency. This includes reward shaping, behavioral cloning, and reverse curriculum generation.
+
+# 1 INTRODUCTION
+
+An important goal of AI research is to construct agents that can learn well in new environments (Levine et al., 2016). An increasingly popular paradigm for this task is deep reinforcement learning (deep RL, Silver et al. (2016); Moravcík et al. (2017); Silver et al. (2017)). However, training an RL agent can take a very long time, particularly in environments with sparse rewards. In these settings, the agent typically requires a large number of episodes to stumble upon positive rewards and learn even a moderately effective policy that can then be refined. This is often resolved via hand-engineering a dense reward function. Such reward shaping, while effective, can also change the set of optimal policies and have unintended side effects $\mathrm { N g }$ et al., 1999; Clark & Amodei, 2016).
+
+We consider an alternative technique for accelerating RL in sparse reward settings. The idea is to create a curriculum for the agent via reversing a single trajectory (i.e. state sequence) of reasonably good, but not necessarily optimal, behavior. We start our agent at the end of a demonstration and let it learn a policy in this easier setup. We then move the starting point backward until the agent is training only on the initial state of the task. We call this technique Backplay.
+
+Our contributions are threefold:
+
+1. We characterize analytically and qualitatively which environments Backplay will aid. 2. We demonstrate Backplay’s effectiveness on both a grid world task (to gain intuition) as well as the four player stochastic zero-sum game Pommerman (MultiAgentLearning, 2018). 3. We empirically show that Backplay compares favorably to other methods that improve sample complexity.
+
+Besides requiring vastly fewer number of samples to learn a good policy, an agent trained with Backplay can outperform its demonstrator and even learn an optimal policy following a sub-optimal demonstration. Our experiments further show Backplay’s strong performance relative to reward shaping (involves hand tuning reward functions), behavioral cloning (not intended for use with sub-optimal experts), and other forms of automatic curriculum generation (Florensa et al. (2017), requires a reversable environment).
+
+# 2 RELATED WORK
+
+The most related work to ours is a blog post describing a method similar to Backplay used to obtain state-of-theart performance on the challenging Atari game Montezuma’s Revenge (Salimans & Chen, 2018). This work was independent of and concurrent to our own. In addition to reporting results on a different, complex stochastic multi-agent environment, we provide an analytic characterization of the method as well as an in depth discussion of what kinds of environments a practitioner can expect Backplay to out or underperform other existing methods.
+
+![](images/cf7f8ad6e3c67f2fc2b5865e835dace28432e332ff9f7bdff2f7f869818e8747.jpg)  
+Figure 1. Backplay: We first collect a demonstration, from which we build a curriculum over the states. We then sample a state according to that curriculum and initialize our agent accordingly.
+
+A popular method for improving RL with   
+access to expert demonstrations is behavioral cloning/imitation learning. These methods explicitly encourage the learned policy to mimic an expert policy (Bain & Sommut, 1999; Ross et al., 2011; Daumé et al., 2009; Zhang & Cho, 2016; Laskey et al., 2016; Nair et al., 2017; Hester et al., 2017; Ho & Ermon, 2016; Aytar et al., 2018; Lerer & Peysakhovich, 2018; Peng et al., 2018). Imitation learning requires access to both state and expert actions (whereas Backplay only requires states) and is designed to copy an expert, thus it cannot, without further adjustments (e.g. as proposed by Gao et al. (2018)), surpass a suboptimal expert. We discuss the pros and cons of an imitation learning $^ +$ adjustment vs. a Backplay-based approach in the main analysis section.
+
+Other algorithms (Ranzato et al., 2015; Li et al., 2016; Das et al., 2017a;b), primarily in dialog, use a Backplay-like curriculum, albeit they utilize behavioral cloning for the first part of the trajectory. This is a major difference as we show that for many classes of problems, we only need to change the initial state distribution and do not see any gains from warm-starting with imitation learning. Backplay is more similar to Conservative Policy Iteration (Kakade & Langford, 2002), a theoretical paper which presents an algorithm designed to operate with an explicit restart distribution.
+
+Also related to Backplay is the method of automatic reverse curriculum generation Florensa et al. (2017). These approaches assumes that the final goal state is known and that the environment is both resettable and reversible. The curricula are generated by taking random walks in the state space to generate starting states or by taking random actions starting at the goal state McAleer et al. (2018). These methods do not require an explicit ‘good enough’ demonstration as Backplay does. However, they require the environment to be reversible, an assumption that doesn’t hold in many realistic tasks such as a robot manipulating breakable objects or complex video games such as Starcraft. In addition, they may fare poorly when random walks reach parts of the state space that are not actually relevant for learning a good policy. Thus, whether a practitioner wants to generate curricula from a trajectory or a random walk depends on the environment’s properties. We discuss this in more detail in our analysis section and show empirical results suggesting that Backplay is superior.
+
+Hosu & Rebedea (2016) use uniformly random states of an expert demonstration as starting states for a policy. Like Backplay, they show that using a single loss function to learn a policy from both demonstrations and rewards can outperform the demonstrator and is robust to sub-optimal demonstrations. However, they do not impose a curriculum over the demonstration and are equivalent to the Uniform baseline in our experiments.
+
+Zhu et al. (2018) use a curriculum but manually tune it for each ‘stage’ of the environment. Within each stage, they use what we call Uniform training, which fails in our most challenging environments.
+
+Goyal et al. (2018) and Edwards et al. (2018) simultaneously proposed the use of a learned backtracking model to generate traces that lead to high value states. Their methods rely on either having the agent visit high reward states or learning a model of the environment capable of generating the states. Both of these are challenging in environments in which the dynamics near starting states are very different from those near goal states.
+
+Finally, Ivanovic et al. (2018) use a known (approximate) dynamics model to create a backwards curriculum for continuous control tasks. Their approach requires a physical prior which is not always available and often not applicable in multi-agent scenarios. In contrast, Backplay automatically creates a curriculum fit for any resettable environment with accompanying demonstrations.
+
+# 3 BACKPLAY
+
+Consider the standard formalism of a single agent Markov Decision Process (MDP) defined by a set of states $s$ , a set of actions $\mathcal { A }$ , and a transition function $\mathcal { T } : \mathcal { S } \times \mathcal { A }  \mathcal { S }$ which gives the probability distribution of the next state given a current state and action. If $\mathcal { P } ( A )$ denotes the space of probability distributions over actions, the agent chooses actions by sampling from a stochastic policy $\pi : { \mathcal { S } }  { \mathcal { P } } ( { \mathcal { A } } )$ , and receives reward $r : S \times \mathcal { A }  \mathbb { R }$ at every time step. The agent’s goal is to construct a policy which minimizes its discounted expected return $\begin{array} { r } { R _ { t } = \bar { \mathbb { E } } \left[ \sum _ { k = 0 } ^ { \infty } \bar { \gamma } ^ { k } r _ { t + k + 1 } \right] } \end{array}$ where $r _ { t }$ is the reward at time $t$ and $\gamma \in [ 0 , 1 ]$ is the discount factor, and the expectation is taken with respect to both the policy and the environment.
+
+The final component of an MDP is the distribution of initial starting states $s _ { 0 }$ . The key idea in demonstration which reaches a sequence of states Backplay is that we do not initialize the MDP in only a fixed $\{ s _ { 0 } ^ { \dot { d } } , s _ { 1 } ^ { d } , \ldots , s _ { T } ^ { d } \}$ $s _ { 0 }$ . Instead, we assume access to a . For each training episode, we uniformly sample starting states from the sub-sequence $\{ s _ { T - k } ^ { d } , s _ { T - k + 1 } ^ { d } , . . . , s _ { T - j } ^ { d } \}$ for some window $[ j , k ]$ . Note that this training regime requires the ability to reset the environment to any state. As training continues, we ‘advance’ the window according to a curriculum by increasing the values of $j$ and $k$ until we are training on the initial state in every episode $( j = k = T )$ ). In this manner, our hyperparameters for Backplay are the windows and the training epochs at which we advance them.
+
+# 3.1 QUANTITATIVE ANALYSIS
+
+Next, we consider a simple environment in which we can analytically show that Backplay will improve the sample-efficiency of RL training.
+
+Consider a connected, undirected graph $G = ( V , E )$ . An agent is placed at a fixed node $v _ { 0 } \in V$ and moves to neighboring nodes at a negative reward of $- 1$ for each step. Its goal is to reach a target node $v _ { * } \in V$ , terminating the episode. This corresponds to an MDP $\overset { \cdot } { \mathcal { M } } = \overset { \cdot } { ( } S , \overset { \cdot } { \mathcal { A } } , P , R )$ with state space $s \sim V$ , action space $A \sim E$ , deterministic transition kernel corresponding to
+
+$$
+P ( s _ { t + 1 } = j \mid s _ { t } = i , a _ { t } = ( l , k ) ) = \delta ( j = k ) \delta ( l = i ) + \delta ( j = i ) \delta ( l \neq i )
+$$
+
+and uniform reward $R ( s _ { t } , a _ { t } ) = - 1$ for $s _ { t + 1 } \neq v _ { * }$ . Assume that $\pi$ is a fixed policy on $\mathcal { M }$ , such that the underlying Markov chain is irreducible and aperiodic:
+
+$$
+K _ { \pi } ( s ^ { \prime } , s ) = \sum _ { a \in \cal { A } } P ( s _ { t + 1 } = s ^ { \prime } \mid s _ { t } = s , a _ { t } = a ) \pi ( a \mid s )
+$$
+
+$K _ { \pi }$ has a single absorbing state at $s = s _ { * } : = v _ { * }$ . Our goal is to estimate the value function of this policy, equivalent to the expected first-passage time of the Markov chain $K _ { \pi }$ from $s _ { 0 } = s$ to $s _ { * }$ :
+
+$$
+V _ { \pi } ( s ) = \mathbb { E } \tau ( s , s _ { * } ) = \mathbb { E } \operatorname* { m i n } \{ j \geq 0 \ ; \ s . t . s _ { j } = s _ { * } , s _ { 0 } = s , s _ { i + 1 } \sim K _ { \pi } ( \cdot , s _ { i } ) \} .
+$$
+
+We consider a special tractable case where the value function can be well approximated by looking at the distance of a state from the goal state. Formally:
+
+Assumption 1. For all $\theta$ $\begin{array} { r } { \mathrm { ~ , ~ } V _ { \theta } ( s ) = V _ { \theta } ( s ^ { \prime } ) \ w h e n e \nu e r d i s t _ { G } ( s ^ { \prime } , s _ { \ast } ) = d i s t _ { G } ( s , s _ { \ast } ) . } \end{array}$
+
+We wish to analyze the process which is the projection of our Markov policy $\pi$ only in terms of the distance $z _ { t }$ . However, now the transition probabilities will not only be a function of only $z _ { t }$ and so
+
+this projection will be non-Markovian. Its Markov approximation $\bar { z } _ { t }$ is defined as the Markov chain $\overline { { K } }$ given by the expected transition probabilities
+
+$$
+\begin{array} { r c l } { { \mathrm { P r } ( \bar { z } _ { t + 1 } = l - 1 | \bar { z } _ { t } = l ) } } & { { = } } & { { \alpha _ { l } : = \mathrm { P r } _ { \mu } ( z _ { t + 1 } = l - 1 | z _ { t } = l ) , } } \\ { { \mathrm { P r } ( \bar { z } _ { t + 1 } = l | \bar { z } _ { t } = l ) } } & { { = } } & { { \beta _ { l } : = \mathrm { P r } _ { \mu } ( z _ { t + 1 } = l | z _ { t } = l ) , l = 0 \ldots M } } \end{array}
+$$
+
+and thus Pr(¯zt+1 = l + 1|z¯ $\ L _ { t } = l ) = 1 - \alpha _ { l } - \beta _ { l } = \operatorname* { P r } _ { \mu } ( z _ { t + 1 } = l + 1 \mid z _ { t } = l$ ) under the stationary distribution $\mu$ of $K _ { \pi }$ .
+
+Assumption 2. The projected process is well described by its Markovian approximation.
+
+Though these assumptions are relatively strong, they makes the analysis of Backplay in this graph complex but analytically tractable. Given a demonstration $\mathbf { d } = ( d _ { 0 } = s _ { 0 } , \ldots , d _ { L } = { \dot { s } } _ { * } )$ , $d _ { l } \in S$ we will perform Backplay
+
+Theorem 1. When assumptions 1 and 2 hold, the sample complexity gains from using Backplay rather than standard RL are exponential in the diameter of the graph. $\begin{array} { r } { O ( \frac { M ^ { 2 } } { m } \alpha ^ { - m } ) } \end{array}$ vs $\Omega ( M \alpha ^ { - M / 2 } )$
+
+3) to obtain Proof. we sample it using a step size $\bar { d } _ { l } : = \mathrm { d i s t } _ { G } ( \breve { d } _ { L - m l } , s _ { * } )$ , l = 0, 1, . . . , Lm , which satisfies (such that mod $\bar { d } _ { l } \leq l m \bar { }$ , where $j$ for all is defined in Section $l$ .
+
+For fixed $l$ , we initialize the chain $\overline { { K } }$ at $\bar { d } _ { l }$ : $\bar { z } _ { 0 } = \bar { d } _ { l }$ . Since $\begin{array} { r } { P r ( \bar { z } _ { m } = 0 ) \geq \prod _ { j = 0 } ^ { m - 1 } \alpha _ { j } : = \gamma _ { 0 , m } } \end{array}$ , after $O ( \gamma _ { 0 , m } ^ { - 1 } )$ trials of length $\leq M$ , we will reach the absorbing state and finally have a signal-carrying update for the Q-function at the originating state.
+
+We can consequently merge that state into the absorbing state and reduce the length of the chain by one. Repeat the argument $m$ times so that after $O ( \sum _ { j = 0 } ^ { m } \gamma _ { j , m } ^ { - 1 } ) = O ( m \gamma _ { 0 , m } ^ { - 1 } )$ trials, the Q-function is updated at $\bar { z } _ { 0 }$ . Repeat at Backplay steps $\begin{array} { r } { m , l = 1 , \dots \frac { M } { m } } \end{array}$ m , and we reach a sample complexity of
+
+$$
+T _ { m } = \sum _ { k = 0 } ^ { \frac { M } { m } - 1 } { \cal O } \left( M \sum _ { j = 0 } ^ { m } \gamma _ { k m , ( k + 1 ) m - j } ^ { - 1 } \right) \ .
+$$
+
+In the case where $\alpha _ { l } = \alpha$ for all $l$ , we obtain $\gamma _ { k m , ( k + 1 ) m - j } ^ { - 1 } = \gamma _ { 0 , m - j } = \alpha ^ { - m + j }$ and therefore $\begin{array} { r } { T _ { m } = O \left( \frac { M ^ { 2 } ( 1 - \alpha ^ { m + 1 } ) } { m ( 1 - \alpha ) } \alpha ^ { - m } \right) } \end{array}$ , where the important term is the rate $\textstyle { \frac { M ^ { 2 } } { m } } \alpha ^ { - m }$ .
+
+On the other hand, Hong & Zhou (2017) shows that the first-passage time $\tau ( 0 , M )$ in a skip-free finite Markov chain of $M$ states with a single absorbing state is a random variable whose momentgenerating function $\varphi ( s ) = \mathbb { E } s ^ { \tau ( s , s _ { * } ) }$ is given by
+
+$$
+\varphi ( s ) = \prod _ { j = 1 } ^ { M } \frac { ( 1 - \lambda _ { j } ) s } { 1 - \lambda _ { j } s } ,
+$$
+
+where $\lambda _ { 1 } , \dots , \lambda _ { M }$ are the non-unit eigenvalues of the transition probability matrix. It follows that $\begin{array} { r } { \mathbb { E } \tau ( 0 , M ) = \varphi ^ { \prime } ( 1 ) = \sum _ { j = 1 } ^ { M } \frac { 1 } { 1 - \lambda _ { j } } \approx ( 1 - \lambda _ { 1 } ) ^ { - 1 } } \end{array}$ , which corresponds to the reciprocal spectral gap.1 Chen & Saloff-Coste (2013) further shows that this reciprocal spectral gap is $\Omega ( \alpha ^ { - M / 2 } )$ in our case, and therefore the model without Backplay will on average take $T _ { M } = \Omega ( \alpha ^ { - M / 2 } )$ trials to reach the absorbing state and receive information. □
+
+We can analyze the uniform strategy similarly. The probability that a trajectory initialized at one of the uniform samples will reach the absorbing state is lower bounded by
+
+$$
+\sum _ { j = 1 } ^ { M } \alpha ^ { j } P ( \bar { z } _ { 0 } = j ) = \frac { 1 } { M } \sum _ { j = 1 } ^ { M } \alpha ^ { j } = \frac { \alpha - \alpha ^ { M + 1 } } { M ( 1 - \alpha ) } ,
+$$
+
+which is approximately $\frac { \alpha } { M }$ when $\alpha$ is small, leading to a sample complexity of $O ( M ^ { 2 } \alpha ^ { - 1 } )$ to update the value function at the originating state, and $O ( M ^ { 3 } \alpha ^ { - 1 } )$ at the starting state. Comparing this rate to Backplay with $m = 1$ , observe that the uniform strategy is slower by a factor of $M$ (and one can verify that the same is true for generic step size $m$ by imagining that we first sampled a window of size $m$ and then sub-sampled our state from that window), suggesting that it loses efficiency on environments with large diameter.
+
+The preceding analysis suggests that a full characterization of Backplay is a fruitful direction for reinforcement and imitation learning theory, albeit beyond the scope of this paper.
+
+# 3.2 QUALITATIVE ANALYSIS
+
+We now provide intuition regarding the conditions under which Backplay can improve sampleefficiency or lead to a better policy than that of the demonstrator. In addition, we discuss the differences between Backplay and other methods of reducing sample complexity for deep RL as well as when practitioners would choose to use one or the other.
+
+Figure 2 contains three grid worlds. In each, the agent begins at $s _ { 0 }$ , receives $+ 1$ when it reaches $s _ { * }$ , and otherwise incurs a per step cost. They each pose a challenge to model free RL and highlight advantages and disadvantages of Backplay compared to other approaches like behavioral cloning (BC, Bain & Sommut (1999)), generative adversarial imitation learning (GAIL, Ho & Ermon (2016)), and reverse curriculum generation (RCG, Florensa et al. (2017)). See Table 1 for a direct comparison of these algorithms.
+
+![](images/80c6f889e484645e180e67926e04933eee7f28c2ac4c3c88a6bf44468b8a2017.jpg)  
+Figure 2. Three environments illustrating when Backplay can help or hinder learning an optimal policy. Backplay is expected to learn faster than standard RL on the first and second mazes, but perform worse on the third maze.
+
+The left grid world shows a sparse reward environment in which Backplay can decrease the requisite training time compared to standard RL. Using the sub-optimal demonstration will position the Backplay agent close to high value states. In addition, the agent will likely surpass the expert policy because, unlike in BC approaches, Backplay does not encourage the agent to imitate expert actions. Rather, the curriculum forces the agent to first explore states with large associated value and, consequently, estimating the value function suffers less from the curse of dimensionality. And finally, we expect it to also surpass results from RCG because random movements from the goal state will progress very haphazardly in such an open world.
+
+The middle grid illustrates a maze with bottlenecks. Backplay will vastly decrease the exploration time relative to standard RL, because the agent will be less prone to exploring the errant right side chamber where it can get lost if it traverses to the right instead of going up to the goal. If we used BC, then the agent will sufficiently learn the optimal policy, however it will suffer when placed in nearby spots on the grid as they will be out of distribution; Backplay-trained agents will not have this problem as they also explore nearby states. When an RCG agent reaches the first fork, it has an even chance of exploring the right side of the grid and wasting lots of sample time.
+
+On the rightmost grid world, while Backplay is still likely to surpass its demonstrator, it will have trouble doing better than standard RL because the latter always starts at $s _ { 0 }$ and consequently is more likely to stumble upon the optimal solution of going up and right. In contrast, Backplay will spend the dominant amount of its early training starting in states in the sub-optimal demonstration. Note that BC will be worse off than Backplay because by learning the demonstration, it will follow the trajectory into the basin instead of going up the right side. Finally, observe that RCG will likely outperform here given that it has a high chance of discovering the left side shortcut and, if not, it would more likely discover the right side shortcut than be trapped in the basin.
+
+In summary, Backplay is not a universal strategy to improve sample complexity. Even in the navigation setting, if the task randomizes the initial state $s _ { 0 }$ , a single demonstration trajectory does not generally improve the coverage of the state-space outside an exponentially small region around said trajectory. For example, imagine a binary tree and a navigation task that starts at a random leaf and needs to reach the root. A single expert trajectory will be disjoint from half of the state space (because the root is absorbing), thus providing no sample complexity gains on average.
+
+Table 1: Comparison of Backplay with related work: Behavioral Cloning (BC), Generative Adversarial Imitation Learning (GAIL), and Reverse Curriculum Generation (RCG).   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Requirements</td><td rowspan=1 colspan=1>Main Idea</td><td rowspan=1 colspan=1>MainWeakness</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>(State,Action) pairs fromexpert trajectory.</td><td rowspan=1 colspan=1>Learn policy that imitates theexpert demonstration.</td><td rowspan=1 colspan=1>Sub-optimal expert can yield avery poor learned policy.</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>(State,Action) pairs fromexpert trajectory.</td><td rowspan=1 colspan=1>Learn a policythat matchesthe distribution of expert tra-jectory pairs.</td><td rowspan=1 colspan=1>Difficult to tune; Requires moreworld interactions; Can performworse than BC.</td></tr><tr><td rowspan=1 colspan=1>RCG</td><td rowspan=1 colspan=1>Reversable transition func-tion of environment; Reset-table environment.</td><td rowspan=1 colspan=1>Take randomwalks from goalstate to build curriculum of ini-tial starting states.</td><td rowspan=1 colspan=1>Complexitymay increase if ran-dom walks reach parts of statespace irrelevant to a good policy.</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>State sequence froma‘good enough’ trajectory;Resettable environment.</td><td rowspan=1 colspan=1>Sample starting state fromgiven trajectory by walkingbackward along trajectory.</td><td rowspan=1 colspan=1>If states in‘good enough&#x27;tra- jectory are not optimal, then canslow learning the optimal policy.</td></tr></table>
+
+# 4 EXPERIMENTS
+
+We now move to evaluating Backplay empirically in two environments: a grid world maze and a four-player free-for-all game. The questions we study across both environments are the following:
+
+• Is Backplay more efficient than training an RL agent from scratch? • How does the quality of the given demonstration affect the effectiveness of Backplay? • Can Backplay agents surpass the demonstrator when it is non-optimal? • Can Backplay agents generalize?
+
+# 4.1 TRAINING DETAILS
+
+We compare several training regimes. The first is Backplay, which uses the Backplay algorithm corresponding to a particular sequence of windows and epochs as specified in A.1. The second, Standard is vanilla model-free RL with the agent always starting at the initial state $s _ { 0 }$ . The last, Uniform, is an ablation that considers how important is the curriculum aspect of Backplay by sampling initial states randomly from the entire demonstration. In all these regimes, we use Proximal Policy Optimization (PPO, Schulman et al. (2017)) to train an agent with policy and value functions parameterized by convolutional neural networks.
+
+On the Maze environment (detailed below), we also ran comparisons against Behavioral Cloning and Reverse Curriculum Generation. We chose BC over GAIL (Ho & Ermon, 2016) for three reasons. First, GAIL requires careful hyperparameter tuning and is thus difficult to train. Second, GAIL requires more environment interactions. And third, GAIL has recently been shown to perform significantly worse than BC (Behbahani et al., 2018).
+
+Training details and network architectures for all the environments can be found in A.3 and A.6, while A.9 contains empirical observations for using Backplay in practice.
+
+# 4.2 MAZE
+
+We generated mazes of size $2 4 \times 2 4$ with 120 randomly placed walls, a random start position, and a random goal position. We then used $\mathbf { A } ^ { * }$ to generate trajectories. These included both Optimal demonstrations (true shortest path) and N-Optimal demonstrations (N steps longer than the shortest path). More details on this setup are given in A.2.
+
+<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>Map Set</td><td rowspan=1 colspan=1>% Optimal</td><td rowspan=1 colspan=1>% 0-5 Optimal</td><td rowspan=1 colspan=1>Avg Suboptimality</td><td rowspan=1 colspan=1> Std Suboptimality</td></tr><tr><td rowspan=1 colspan=1>Standard</td><td rowspan=1 colspan=1>All</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>Uniform</td><td rowspan=1 colspan=1>Optimal</td><td rowspan=1 colspan=1>27</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>8.26</td><td rowspan=1 colspan=1>32.92</td></tr><tr><td rowspan=1 colspan=1>Uniform</td><td rowspan=1 colspan=1>5-Optimal</td><td rowspan=1 colspan=1>51</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>2.04</td><td rowspan=1 colspan=1>17.39</td></tr><tr><td rowspan=1 colspan=1>Uniform</td><td rowspan=1 colspan=1>10-Optimal</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>2.04</td><td rowspan=1 colspan=1>16.79</td></tr><tr><td rowspan=1 colspan=1>Florensa</td><td rowspan=1 colspan=1>Optimal</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>51</td><td rowspan=1 colspan=1>63.36</td><td rowspan=1 colspan=1>78.08</td></tr><tr><td rowspan=1 colspan=1>Florensa</td><td rowspan=1 colspan=1>5-Optimal</td><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>77</td><td rowspan=1 colspan=1>25.44</td><td rowspan=1 colspan=1>56.89</td></tr><tr><td rowspan=1 colspan=1>Florensa</td><td rowspan=1 colspan=1>10-Optimal</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>69</td><td rowspan=1 colspan=1>39.75</td><td rowspan=1 colspan=1>70.92</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>Optimal</td><td rowspan=1 colspan=1>31</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>0.64</td><td rowspan=1 colspan=1>4.96</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>5-Optimal</td><td rowspan=1 colspan=1>37</td><td rowspan=1 colspan=1>94</td><td rowspan=1 colspan=1>7.94</td><td rowspan=1 colspan=1>33.35</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>10-Optimal</td><td rowspan=1 colspan=1>54</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>0.37</td><td rowspan=1 colspan=1>3.49</td></tr></table>
+
+Table 2: Results after 2000 epochs on 100 mazes. Note that for Backplay and Uniform, the Map Set is also the type of demonstrator, where N-optimal has demonstrations $\mathbf { N }$ steps longer than the shortest path. From left to right, the table shows: the percentage of mazes on which the agent optimally reaches the goal, percentage on which it reaches in at most five steps more than optimal, and the average and standard deviation of extra steps over optimal. Both Backplay and Uniform succeed on almost all mazes and, importantly, can outperform the experts’ demonstrations. On the other hand, Standard does not learn a useful policy and Florensa fails to learn more than $5 0 - 7 0 \%$ of the maps, which is why its sub-optimality mean and std is so high. Results for Backplay were generally consistent across all seeds. For others, we report their best score. See A.4 for further details.
+
+Our model receives as input four $2 4 \times 2 4$ binary maps. They contain ones at the positions of, respectively, the agent, the goal, passages, and walls. It outputs one of five options: Pass, Up, Down, Left, or Right. The game ends when the agent has reached its goal or after a maximum of 200 steps, whereupon the agent receives reward of $+ 1$ if it reaches the goal and a per step penalty of -0.03.
+
+Backplay, Uniform, Standard. Table 2 shows that Standard has immense trouble learning in this sparse reward environment while both Backplay and Uniform find an optimal path approximately 30- $50 \%$ of the time and a path within five of the optimal path almost always. Thus, in this environment, demonstrations of even sub-optimal experts are extremely useful, while the curriculum created by Backplay is not necessary. That curriculum does, however, aid convergence speed (A.4). We will see in 4.3 that the curriculum becomes vital as the environment increases in complexity.
+
+Behavioral Cloning. We trained an agent using behavioral cloning from the same trajectories as the ones used for Backplay. While the agent learns to perfectly imitate those trajectories, we had immense difficult doing better than the expert. All of our attempts to use reward signal to improve the agent’s performance (over that of the behaviorally cloned agent) were unsuccessful, even after incorporating tricks in the literature such as those found in Schmitt et al. (2018). One possible reason is that the agent has no information about states outside of the demonstration trajectory.
+
+Reverse Curriculum Generation. We also compared Backplay to the method proposed by Florensa et al. (2017). As illustrated in Table 2 and Section A.4, Florensa agents perform significantly worse with higher sample complexity variance compared to Backplay (or Uniform). This suggests that having demonstrations helps inordinately. Further details can be found in A.3.
+
+# 4.3 POMMERMAN
+
+Pommerman is a stochastic environment (Resnick et al., 2018) based on the classic console game Bomberman and will be a competition at NeurIPS 2018. It is played on an 11x11 grid where on every turn, each of four agents either move in a cardinal direction, pass, or lay a bomb. The agents begin fenced in their own area by two different types of walls - rigid and wooden. The former are indestructible while bombs destroy the latter. Upon blowing up wooden walls, there is a uniform chance at yielding one of three power-ups: an extra bomb, an extra unit of range in the agent’s bombs, or the ability to kick bombs. The maps are designed randomly, albeit there is always a guaranteed path between any two agents. For a visual aid of the start state, see Figure 8 in A.5.
+
+In our experiments, we use the purely adversarial Free-For-All (FFA) environment. This environment is introduced in (MultiAgentLearning, 2018; Resnick et al., 2018) and we point the reader there for more details. The winner of the game is the last agent standing. It is played from the perspective of one agent whose starting position is uniformly picked among the four. The three opponents are copies of the winner of the June 3rd 2018 FFA competition, a stochastic agent using a Finite State Machine Tree-Search approach (FSMTS, Zhou et al. (2018)). We also make use of the FSMTS agent as the ‘expert’ in the Backplay demonstrations.
+
+The observation state is represented by 19 11x11 maps, and we feed the concatenated last two states to our agent as input. A detailed description of this mapping is given in A.5. The game ends either when the learning agent wins or dies, or when 800 steps have passed. Upon game end, the agent receives $+ 1$ for winning and $- 1$ otherwise (Sparse). We also run experiments where the agent additionally receives $+ 0 . 1$ whenever it collects an item (Dense).
+
+![](images/6fb655e834f82f1f2fc914d07474766c75d5578066da4028f1af9df41f349a66.jpg)  
+Figure 3. Pommerman results (5 seeds) when training with sparse rewards. Plots a and $\mathbf { b }$ are trained from the perspective of the winning agent, while c is trained from that of the runner up. The red bar indicates when the Backplay models begin training only on the initial state. Plot a is our starkest result and displays results on games starting from the initial state only regardless of when training occurs. you can see here that Backplay attains strong results where Uniform and Standard fail to learn anything of note.
+
+![](images/9075ba624117740d560bc365ca0cba6177e44e0898a5d3c9a64593cbaa86e0f3.jpg)  
+Figure 4. Pommerman results (5 seeds) when training with dense rewards. Again, a and $\mathbf { b }$ are trained from the perspective of the winning agent, while c is trained from that of the runner up. The cause of the higher variance in a was one of the seeds was worse than the others. Nonetheless, they all still did much better than either Standard or Uniform.
+
+Our first three scenarios follow the Sparse setup. We independently consider three Backplay trajectories, one following the winner over 100 maps, one following the winner over four maps, and one following the runner up over four maps, with the latter two set of maps being the same. Figure 3 shows that Backplay can soundly defeat the FSMTS agents in sparse settings when following the winner, even when there are 100 maps to consider, while other methods struggle in this setup. Modulo higher variance in Backplay’s result, we see a similar comparison in the runner-up case. Visit this link for an example gif of our trained Backplay agent (top left - red). Note that our agent learned to ‘throw’ bombs, a unique playing style that no prior Pommerman competitor had exhibited, including the FSMTS demonstrator.
+
+Moreover, by training on 100 maps, Backplay generalizes (to some extent) on unseen boards. Backplay wins 416 / 1000 games on a held out set of ten maps, with the following success rates on each: $8 5 . 3 \%$ , $8 4 . 1 \%$ , $8 1 . 6 \%$ , $7 9 . 5 \%$ , $5 2 . 4 \%$ , $4 7 . 4 \%$ , $3 8 . 1 \%$ , $2 2 . 6 \%$ , $20 \%$ , and $1 8 . 3 \%$ . This was in contrast to our Maze experiments where no approach generalized. Given this discrepancy, we believe that the lack of generalization was a consequence of not including enough mazes during training.
+
+# 5 CONCLUSION
+
+We have introduced and analyzed Backplay, a technique which improves the sample efficiency of model-free RL by constructing a curriculum around a demonstration. We showed that Backplay agents can learn in complex environments where standard model-free RL fails, that they can outperform the ‘expert’ whose trajectories they use while training, and that they compare very favorably to related methods such as reversible curriculum generation. We also presented a theoretical analysis of its sample complexity gains in a simplified setting.
+
+An important future direction is combining Backplay with more complex and complementary methods such as Monte Carlo Tree Search (MCTS, (Browne et al., 2012; Vodopivec et al., 2017)). There are many potential ways to do so, for example by using Backplay to warm-start MCTS.
+
+Another direction is to use Backplay to accelerate self-play learning in zero-sum games. However, special care needs to be taken to avoid policy correlation during training (Lanctot et al., 2017) and thus to make sure that learned strategies are safe and not exploitable (Brown & Sandholm, 2017).
+
+A third direction is towards non-zero sum games. It is well known that standard independent multiagent learning does not produce agents that are able to cooperate in social dilemmas (Leibo et al., 2017; Lerer & Peysakhovich, 2017; Peysakhovich & Lerer, 2017; Foerster et al., 2017) or risky coordination games (Yoshida et al., 2008; Peysakhovich & Lerer, 2018). In contrast, humans are much better at finding these coordinating and cooperating equilibria (Bó, 2005; Kleiman-Weiner et al., 2016). Thus, we conjecture that human demonstrations can be combined with Backplay to construct agents that perform well in such situations.
+
+Other future priorities are to gain further understanding into when Backplay works well, when it fails, and how we can make the procedure more efficient. Could we speed up Backplay by ascertaining confidence estimates of state values? Do the gains in sample complexity come from value estimation like our analysis suggests, from policy iteration, or from both? Is there an ideal rate for advancing the curriculum window and is there a better approach than a hand-tuned schedule?
+
+# REFERENCES
+
+Yusuf Aytar, Tobias Pfaff, David Budden, Tom Le Paine, Ziyu Wang, and Nando de Freitas. Playing hard exploration games by watching youtube. arXiv preprint arXiv:1805.11592, 2018.   
+Michael Bain and Claude Sommut. A framework for behavioural claning. Machine intelligence, 15 (15):103, 1999.   
+Feryal Behbahani, Kyriacos Shiarlis, Xi Chen, Vitaly Kurin, Sudhanshu Kasewa, Ciprian Stirbu, João Gomes, Supratik Paul, Frans A Oliehoek, João Messias, et al. Learning from demonstration in the wild. arXiv preprint arXiv:1811.03516, 2018.   
+Pedro Dal Bó. Cooperation under the shadow of the future: experimental evidence from infinitely repeated games. American economic review, 95(5):1591–1604, 2005.   
+Noam Brown and Tuomas Sandholm. Safe and nested subgame solving for imperfect-information games. In Advances in Neural Information Processing Systems, pp. 689–699, 2017.   
+Cameron B Browne, Edward Powley, Daniel Whitehouse, Simon M Lucas, Peter I Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of monte carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in games, 4(1):1–43, 2012.   
+Guan-Yu Chen and Laurent Saloff-Coste. On the mixing time and spectral gap for birth and death chains. arXiv preprint arXiv:1304.4346, 2013.   
+J. Clark and D. Amodei. Faulty reward functions in the wild. https://blog.openai.com/ faulty-reward-functions/, 2016.   
+Abhishek Das, Samyak Datta, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Embodied question answering. CoRR, abs/1711.11543, 2017a.
+
+Abhishek Das, Satwik Kottur, José M. F. Moura, Stefan Lee, and Dhruv Batra. Learning cooperative visual dialog agents with deep reinforcement learning. CoRR, abs/1703.06585, 2017b.
+
+Hal Daumé, John Langford, and Daniel Marcu. Search-based structured prediction. Machine learning, 75(3):297–325, 2009.
+
+Ashley D Edwards, Laura Downs, and James C Davidson. Forward-backward reinforcement learning. arXiv preprint arXiv:1803.10227, 2018.
+
+Carlos Florensa, David Held, Markus Wulfmeier, and Pieter Abbeel. Reverse curriculum generation for reinforcement learning. arXiv preprint arXiv:1707.05300, 2017.
+
+Jakob N Foerster, Richard Y Chen, Maruan Al-Shedivat, Shimon Whiteson, Pieter Abbeel, and Igor Mordatch. Learning with opponent-learning awareness. arXiv preprint arXiv:1709.04326, 2017.
+
+Yang Gao, Ji Lin, Fisher Yu, Sergey Levine, Trevor Darrell, et al. Reinforcement learning from imperfect demonstrations. arXiv preprint arXiv:1802.05313, 2018.
+
+Anirudh Goyal, Philemon Brakel, William Fedus, Timothy Lillicrap, Sergey Levine, Hugo Larochelle, and Yoshua Bengio. Recall traces: Backtracking models for efficient reinforcement learning. arXiv preprint arXiv:1804.00379, 2018.
+
+Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Gabriel Dulac-Arnold, et al. Deep q-learning from demonstrations. arXiv preprint arXiv:1704.03732, 2017.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016.
+
+Wenming Hong and Ke Zhou. A note on the passage time of finite-state markov chains. Communications in Statistics-Theory and Methods, 46(1):438–445, 2017.
+
+Ionel-Alexandru Hosu and Traian Rebedea. Playing atari games with deep reinforcement learning and human checkpoint replay. arXiv preprint arXiv:1607.05077, 2016.
+
+Boris Ivanovic, James Harrison, Apoorva Sharma, Mo Chen, and Marco Pavone. Barc: Backward reachability curriculum for robotic reinforcement learning. arXiv preprint arXiv:1806.06161, 2018.
+
+Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In Claude Sammut and Achim G. Hoffmann (eds.), ICML, pp. 267–274. Morgan Kaufmann, 2002. ISBN 1-55860-873-7. URL http://dblp.uni-trier.de/db/conf/icml/ icml2002.html#KakadeL02.
+
+Max Kleiman-Weiner, Mark K Ho, Joseph L Austerweil, Michael L Littman, and Joshua B Tenenbaum. Coordinate to cooperate or compete: abstract goals and joint intentions in social interaction. In COGSCI, 2016.
+
+Marc Lanctot, Vinicius Zambaldi, Audrunas Gruslys, Angeliki Lazaridou, Julien Perolat, David Silver, Thore Graepel, et al. A unified game-theoretic approach to multiagent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 4190–4203, 2017.
+
+Michael Laskey, Sam Staszak, Wesley Yu-Shu Hsieh, Jeffrey Mahler, Florian T Pokorny, Anca D Dragan, and Ken Goldberg. Shiv: Reducing supervisor burden in dagger using support vectors for efficient learning from demonstrations in high dimensional state spaces. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pp. 462–469. IEEE, 2016.
+
+Joel Z Leibo, Vinicius Zambaldi, Marc Lanctot, Janusz Marecki, and Thore Graepel. Multi-agent reinforcement learning in sequential social dilemmas. In Proceedings of the 16th Conference on Autonomous Agents and MultiAgent Systems, pp. 464–473. International Foundation for Autonomous Agents and Multiagent Systems, 2017.
+
+Adam Lerer and Alexander Peysakhovich. Maintaining cooperation in complex social dilemmas using deep reinforcement learning. arXiv preprint arXiv:1707.01068, 2017.
+
+Adam Lerer and Alexander Peysakhovich. Learning social conventions in markov games. arXiv preprint arXiv:1806.10071, 2018.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016. URL http: //jmlr.org/papers/v17/15-522.html.
+
+Jiwei Li, Will Monroe, Alan Ritter, Michel Galley, Jianfeng Gao, and Dan Jurafsky. Deep reinforcement learning for dialogue generation. CoRR, abs/1606.01541, 2016.
+
+Stephen McAleer, Forest Agostinelli, Alexander Shmakov, and Pierre Baldi. Solving the rubik’s cube without human knowledge. arXiv preprint arXiv:1805.07470, 2018.
+
+Matej Moravcík, Martin Schmid, Neil Burch, Viliam Lisý, Dustin Morrill, Nolan Bard, Trevor Davis, Kevin Waugh, Michael Johanson, and Michael H. Bowling. Deepstack: Expert-level artificial intelligence in no-limit poker. CoRR, abs/1701.01724, 2017. URL http://arxiv.org/abs/ 1701.01724.
+
+MultiAgentLearning. Pommerman. https://github.com/MultiAgentLearning/ playground, 2018.
+
+Ashvin Nair, Bob McGrew, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Overcoming exploration in reinforcement learning with demonstrations. arXiv preprint arXiv:1709.10089, 2017.
+
+Andrew Y Ng, Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, volume 99, pp. 278–287, 1999.
+
+Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018.
+
+Alexander Peysakhovich and Adam Lerer. Consequentialist conditional cooperation in social dilemmas with imperfect information. arXiv preprint arXiv:1710.06975, 2017.
+
+Alexander Peysakhovich and Adam Lerer. Prosocial learning agents solve generalized stag hunts better than selfish ones. Proceedings of the 17th Conference on Autonomous Agents and MultiAgent Systems, 2018.
+
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. CoRR, abs/1511.06732, 2015.
+
+Cinjon Resnick, Wes Eldridge, David Ha, Denny Britz, Jakob Foerster, Julian Togelius, Kyunghyun Cho, and Joan Bruna. Pommerman: A multi-agent playground, 2018.
+
+Stéphane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011.
+
+Tim Salimans and Richard Chen. Learning montezuma’s revenge from a single demonstration. https://blog.openai.com/ learning-montezumas-revenge-from-a-single-demonstration/, 2018. Accessed: 2018-07-12.
+
+Simon Schmitt, Jonathan J Hudson, Augustin Zidek, Simon Osindero, Carl Doersch, Wojciech M Czarnecki, Joel Z Leibo, Heinrich Kuttler, Andrew Zisserman, Karen Simonyan, et al. Kickstarting deep reinforcement learning. arXiv preprint arXiv:1803.03835, 2018.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, Timothy P. Lillicrap, Karen Simonyan, and Demis Hassabis. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. CoRR, abs/1712.01815, 2017. URL http://arxiv.org/ abs/1712.01815.
+
+Tom Vodopivec, Spyridon Samothrakis, and Branko Šter. On monte carlo tree search and reinforcement learning. J. Artif. Int. Res., 60(1):881–936, September 2017. ISSN 1076-9757. URL http://dl.acm.org/citation.cfm?id $\equiv$ 3207692.3207712.
+
+Wako Yoshida, Ray J Dolan, and Karl J Friston. Game theory of mind. PLoS computational biology, 4(12):e1000254, 2008.
+
+Jiakai Zhang and Kyunghyun Cho. Query-efficient imitation learning for end-to-end autonomous driving. arXiv preprint arXiv:1605.06450, 2016.
+
+Hongwei Zhou, Yichen Gong, Luvneesh Mugrai, Ahmed Khalifa, Andy Nealen, and Julian Togelius. A hybrid search agent in pommerman. In Proceedings of the 13th International Conference on the Foundations of Digital Games, FDG ’18, pp. 46:1–46:4, New York, NY, USA, 2018. ACM. ISBN 978-1-4503-6571-0. doi: 10.1145/3235765.3235812. URL http://doi.acm.org/10. 1145/3235765.3235812.
+
+Yuke Zhu, Ziyu Wang, Josh Merel, Andrei A. Rusu, Tom Erez, Serkan Cabi, Saran Tunyasuvunakool, János Kramár, Raia Hadsell, Nando de Freitas, and Nicolas Heess. Reinforcement and imitation learning for diverse visuomotor skills. CoRR, abs/1802.09564, 2018.
+
+# A APPENDIX
+
+# A.1 BACKPLAY HYPERPARAMETERS
+
+As mentioned in Section 3, the Backplay hyperparameters are the window bounds and the frequency with which they are shifted. When we get to a training epoch represented in the sequence of epochs, we advance to the corresponding value in the sequence of windows. For example, consider training an agent with Backplay in the Maze environment (Table 3) and assume we are at epoch 1000. We will select a maze at random, an $N \in [ 1 6 , 3 2 )$ , and start the agent in that game $N$ steps from the end. Whenever a pair is chosen such that the game’s length is smaller than $N$ , we use the initial state.
+
+There isn’t any downside to having the model continue training in a window for too long, albeit the ideal is that this method increases the speed of training. There is however a downside to advancing the window too quickly. A scenario common to effective training is improving success curves punctured by step drops whenever the window advances.
+
+Table 3: Backplay hyperparameters for Maze.   
+
+<table><tr><td>Starting at training epoch</td><td>Uniform window</td></tr><tr><td>0</td><td>[0,4)</td></tr><tr><td>350</td><td>[4,8)</td></tr><tr><td>700</td><td>[8,16)</td></tr><tr><td>1050</td><td>[16,32)</td></tr><tr><td>1400</td><td>[32, 64)</td></tr><tr><td>1750</td><td>[64,64)</td></tr></table>
+
+Table 4: Backplay hyperparameters for Pommerman 4 maps.   
+
+<table><tr><td>Starting at training epoch</td><td>Uniform window</td></tr><tr><td>0</td><td>[0,32)</td></tr><tr><td>50</td><td>[24,64)</td></tr><tr><td>100</td><td>[56,128)</td></tr><tr><td>150</td><td>[120,256)</td></tr><tr><td>200</td><td>[248, 512)</td></tr><tr><td>250</td><td>[504,800)</td></tr><tr><td>300</td><td>[800,800]</td></tr></table>
+
+Table 5: Backplay hyperparameters for Pommerman 100 maps.   
+
+<table><tr><td>Starting at training epoch</td><td>Uniformwindow</td></tr><tr><td>0</td><td>[0,32)</td></tr><tr><td>85</td><td>[24,64)</td></tr><tr><td>170</td><td>[56,128)</td></tr><tr><td>255</td><td>[120,256)</td></tr><tr><td>340</td><td>[248,512)</td></tr><tr><td>425</td><td>[504, 800)</td></tr><tr><td>510</td><td>[800,800]</td></tr></table>
+
+# A.2 MAZE: DEMONSTRATION DETAILS
+
+For N-Optimal demonstrations, we used a noisy $\mathbf { A } ^ { * }$ where at each step, we follow $\mathbf { A } ^ { * }$ with probability $p$ or choose a random action otherwise. We considered $N \in \{ 5 , 1 0 \}$ . In all scenarios, we only selected maps in which there exists at least a path from the the initial state to the goal state, we filtered any path that was less than 35 in length and stopped when we found a hundred valid training games. Note that we held the demonstration length invariant rather than the optimal length (i.e. all N-optimal paths have the same length regardless of N, which means that the length of the optimal path of a N-optimal demonstration decreases with N). This could explain why the results in Table 2 (column 1) show that Backplay’s performance increases with $_ \mathrm { N }$ (since the larger the N, the smaller the true optimal path, so the easier it is to learn an optimal policy for that maze configuration).
+
+A.3 MAZE: NETWORK ARCHITECTURE AND TRAINING PARAMETERS
+
+We use a standard deep RL setup for our agents. The agent’s policy and value functions are parameterized by a convolutional neural network with 2 layers each of 32 output channels, followed by two linear layers with 128 dimensions. Each of the layers are followed by ReLU activations. This body then feeds two heads, a scalar value function and a softmax policy function over the five actions. All of the CNN kernels are 3x3 with stride and padding of one.
+
+We train our agent using Proximal Policy Optimization (PPO, Schulman et al. (2017)) with $\gamma = 0 . 9 9$ , learning rate $\mathrm { \check { 1 } } \times 1 0 ^ { - 3 }$ , batch size 102400, 60 parallel workers, clipping parameter 0.2, generalized advantage estimation with $\tau = 0 . 9 5$ , entropy coefficient 0.01, value loss coefficient 0.5, mini-batch size 5120, horizon 1707, and 4 PPO updates at each iteration. The number of interactions per epoch is equal to the batch size (102400).
+
+The hyperparameters used for training the agent with Reverse Curriculum Generation (Florensa et al., 2017) are: $1 0 ^ { 4 }$ rollout states for nearby sampling, 50 Brownian steps, 200 samples from new starts, 100 samples from old starts, interval for the expected return [0.1, 0.9].
+
+# A.4 MAZE: LEARNING CURVES
+
+Below are our learning curves for the Maze challenge over five seeds. Note that we do not show any results for Standard as it failed to learn much of anything in the time allotted (3500 epochs). Also note that Backplay occasionally sees the actual grid starting position from epoch 1400, but it becomes the default starting state at epoch 1750. To align with this, our Florensa baseline switches to training from the actual start position at epoch 1750, and we show results for Uniform only over the initial starting state. Correspondingly, we show the graphs from epoch 1000 as all of the methods have commensurately poor results before that time.
+
+![](images/9683ae6ed274a6f5a198d8346d1fc4c297be1738c3474374ec9f07db24dcb867.jpg)  
+Figure 5. Maze results when training with demonstrations of length equal to the optimal path length. Note that Backplay has a very small variance and a very high success rate as early as epoch 1800. On the other hand, Florensa fails to break $70 \%$ and has a high variance, and Uniform doesn’t achieve a strong success rate until epoch 3000.
+
+![](images/6c9d50dd06c913c8b6a47a3e64624e2b4635303e1ce588f85fbb562e7dda40ba.jpg)  
+Figure 6. Maze results when training with demonstrations that are five steps longer than the optimal path length. Compared to the prior graph, Backplay doesn’t do as well, albeit it still performs favorably compared to Florensa, with a consistently higher expected return. Its advantage over Uniform is a reduced amount of necessary samples.
+
+![](images/27cbb6f8732e3a701353a515becbf95c1b3b9eddcd0f02bbed31cb4c37149d2e.jpg)  
+Figure 7. Maze results when training with demonstrations that are ten steps longer than the optimal path length. We again see that Backplay does very well compared to the Florensa baseline, with a much stronger expected return and lower variance. We also see, however, that Uniform is an able competitor to both of these as the expert becomes more suboptimal.
+
+# A.5 POMMERMAN: OBSERVATION STATE
+
+![](images/1d4a42cfa8224d99a5d25bf7cf28bb43b8e5fda4938db59e2d2add13320321ab.jpg)  
+Figure 8. Pommerman start state. Each agent begins in one of four positions. Yellow squares are wood, brown are rigid, and gray are passages.
+
+There are 19 feature maps that encompass each observation. They consist of the following: the agents’ identities and locations, the locations of the walls, power-ups, and bombs, the bombs’ blast strengths and remaining life counts, and the current time step.
+
+The first map contains the integer values of each bomb’s blast strength at the location of that bomb. The second map is similar but the integer value is the bomb’s remaining life. At all other positions, the first two maps are zero. The next map is binary and contains a single one at the agent’s location. If the agent is dead, this map is zero everywhere. The following two maps are similar. One is full with the agent’s integer current bomb count, the other with its blast radius. We then have a full binary map that is one if the agent can kick and zero otherwise.
+
+The next maps deal with the other agents. The first contains only ones if the agent has a teammate and zeros otherwise. This is useful for building agents that can play both team and solo matches. If the agent has a teammate, the next map is binary with a one at the teammate’s location (and zero if she is not alive). Otherwise, the agent has three enemies, so the next map contains the position of the enemy that started in the diagonally opposed corner from the agent. The following two maps contain the positions of the other two enemies, which are present in both solo and team games.
+
+We then include eight feature maps representing the respective locations of passages, rigid walls, wooden walls, flames, extra-bomb power-ups, increase-blast-strength power-ups, and kicking-ability power-ups. All are binary with ones at the corresponding locations.
+
+Finally, we include a full map with the float ratio of the current step to the total number of steps. This information is useful for distinguishing among observation states that are seemingly very similar, but in reality are very different because the game has a fixed ending step where the agent receives negative reward for not winning.
+
+# A.6 POMMERMAN: NETWORK ARCHITECTURE AND TRAINING PARAMETERS
+
+We use a similar setup to that used in the Maze game. The architecture differences are that we have an additional two convolutional layers at the beginning, use 256 output channels, and have output dimensions of 1024 and 512, respectively, for the linear layers. This architecture was not tuned at all duringrate of $3 \times 1 0 ^ { - 4 }$ of our experiments. Further hyperparameter differences are that wand a gamma of 1.0. These models trained for 72 hours, which is ${ \sim } 5 0 \mathrm { M }$ a learning frames. 2
+
+![](images/a92a40429cbdf3082c148b0c130b7d79543e398b569c02ef95298a350467e734.jpg)  
+Figure 9. Typical histograms for how the Pommerman action selections change over time. From left to right are the concatenated counts of the actions (Pass, Up, Down, Left, Right, Bomb), delineated on the y-axis by the epoch. Note how the Standard agent learns to not use bombs.
+
+Pommerman can be difficult for reinforcement learning agents. The agent must learn to effectively wield the bomb action in order to win against competent opponents. However, bombs destroy agents indiscriminately, so placing one without knowing how to retreat often results in negative reward for that agent. Since agents begin in an isolated area, they are prone to converging to policies which do not use the bomb action (as seen in the histograms in Figure 9), which leads them to sub-optimal policies in the long-term.
+
+# A.8 POMMERMAN: WIN RATES
+
+Here we show the per-map win rates obtained by the agent trained with Backlpay on the 100 Pommerman maps.
+
+<table><tr><td rowspan=1 colspan=1>Win</td><td rowspan=1 colspan=1>Maps</td></tr><tr><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=1>24</td></tr><tr><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>26</td></tr><tr><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>6</td></tr><tr><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>5</td></tr></table>
+
+Table 6: Aggregate per-map win rates of the model trained with Backplay on 100 Pommerman maps. The model was run over 5000 times in total, with at least 32 times on each of the 100 maps. The Maps column shows the number of maps on which the Backplay agent had a success rate of at least the percent in the Win column. Note that this model has a win rate of $> 8 0 \%$ on more than half of the maps and a win rate of $> 5 0 \%$ on all maps.
+
+# A.9 PRACTICAL FINDINGS
+
+We trained a large number of models through our research into Backplay. Though these findings are tangential to our main points (and are mainly qualitative), we list some observations here that may be helpful for other researchers working with Backplay.
+
+First, we found that Backplay does not perform well when the curriculum is advanced too quickly, however it does not fail when the curriculum is advanced ‘too slowly.’ Thus, researchers interested in using Backplay should err on the side of advancing the window too slowly rather than too quickly.
+
+Second, we found that Backplay does not need to hit a high success rate before advancing the starting state window. Initially, we tried using adaptive approaches that advanced the window when the agent reached a certain success threshold. This worked but was too slow. Our hypothesis is that what is more important is that the agent gets sufficiently exposed to enough states to attain a reasonable barometer of their value rather than that the agent learns a perfectly optimal policy for a particular set of starting states.
+
+Third, Backplay can still recover if success goes to zero. This surprising and infrequent result occurred at the juncture where the window moved back to the initial state and even if the policy’s entropy over actions became maximal. We are unsure what differentiates these models from the ones that did not recover.
+
+We also explored using DAgger (Ross et al. (2011)) for training our agent, but found that it achieved approximately the same win rate $( \sim 2 0 \% )$ ) as what we would expect when four FSMTS agents played each other (given that there are also ties).

parse/train/H1xk8jAqKQ/H1xk8jAqKQ_content_list.json

@@ -0,0 +1,2101 @@
+[
+    {
+        "type": "text",
+        "text": "BACKPLAY: ‘MAN MUSS IMMER UMKEHREN’ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            714,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cinjon Resnick∗ NYU cinjon@nyu.edu ",
+        "bbox": [
+            184,
+            145,
+            323,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Roberta Raileanu∗ NYU rr3009@nyu.edu ",
+        "bbox": [
+            428,
+            145,
+            566,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sanyam Kapoor NYU sanyam@nyu.edu ",
+        "bbox": [
+            673,
+            145,
+            813,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alexander Peysakhovich FAIR alexpeys@fb.com ",
+        "bbox": [
+            183,
+            208,
+            356,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho   \nNYU, FAIR   \nkyunghyun.cho@nyu.edu   \nJoan Bruna   \nNYU, FAIR   \nbruna@cims.nyu.edu ",
+        "bbox": [
+            385,
+            208,
+            594,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            622,
+            208,
+            802,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            286,
+            544,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model-free reinforcement learning (RL) requires a large number of trials to learn a good policy, especially in environments with sparse rewards. We explore a method to improve the sample efficiency when we have access to demonstrations. Our approach, Backplay, uses a single demonstration to construct a curriculum for a given task. Rather than starting each training episode in the environment’s fixed initial state, we start the agent near the end of the demonstration and move the starting point backwards during the course of training until we reach the initial state. Our contributions are that we analytically characterize the types of environments where Backplay can improve training speed, demonstrate the effectiveness of Backplay both in large grid worlds and a complex four player zero-sum game (Pommerman), and show that Backplay compares favorably to other competitive methods known to improve sample efficiency. This includes reward shaping, behavioral cloning, and reverse curriculum generation. ",
+        "bbox": [
+            232,
+            319,
+            766,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            336,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An important goal of AI research is to construct agents that can learn well in new environments (Levine et al., 2016). An increasingly popular paradigm for this task is deep reinforcement learning (deep RL, Silver et al. (2016); Moravcík et al. (2017); Silver et al. (2017)). However, training an RL agent can take a very long time, particularly in environments with sparse rewards. In these settings, the agent typically requires a large number of episodes to stumble upon positive rewards and learn even a moderately effective policy that can then be refined. This is often resolved via hand-engineering a dense reward function. Such reward shaping, while effective, can also change the set of optimal policies and have unintended side effects $\\mathrm { N g }$ et al., 1999; Clark & Amodei, 2016). ",
+        "bbox": [
+            174,
+            558,
+            825,
+            670
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider an alternative technique for accelerating RL in sparse reward settings. The idea is to create a curriculum for the agent via reversing a single trajectory (i.e. state sequence) of reasonably good, but not necessarily optimal, behavior. We start our agent at the end of a demonstration and let it learn a policy in this easier setup. We then move the starting point backward until the agent is training only on the initial state of the task. We call this technique Backplay. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            746
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are threefold: ",
+        "bbox": [
+            174,
+            753,
+            382,
+            767
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. We characterize analytically and qualitatively which environments Backplay will aid. 2. We demonstrate Backplay’s effectiveness on both a grid world task (to gain intuition) as well as the four player stochastic zero-sum game Pommerman (MultiAgentLearning, 2018). 3. We empirically show that Backplay compares favorably to other methods that improve sample complexity. ",
+        "bbox": [
+            210,
+            779,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Besides requiring vastly fewer number of samples to learn a good policy, an agent trained with Backplay can outperform its demonstrator and even learn an optimal policy following a sub-optimal demonstration. Our experiments further show Backplay’s strong performance relative to reward shaping (involves hand tuning reward functions), behavioral cloning (not intended for use with sub-optimal experts), and other forms of automatic curriculum generation (Florensa et al. (2017), requires a reversable environment). ",
+        "bbox": [
+            176,
+            872,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            343,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The most related work to ours is a blog post describing a method similar to Backplay used to obtain state-of-theart performance on the challenging Atari game Montezuma’s Revenge (Salimans & Chen, 2018). This work was independent of and concurrent to our own. In addition to reporting results on a different, complex stochastic multi-agent environment, we provide an analytic characterization of the method as well as an in depth discussion of what kinds of environments a practitioner can expect Backplay to out or underperform other existing methods. ",
+        "bbox": [
+            174,
+            236,
+            442,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf7f8ad6e3c67f2fc2b5865e835dace28432e332ff9f7bdff2f7f869818e8747.jpg",
+        "image_caption": [
+            "Figure 1. Backplay: We first collect a demonstration, from which we build a curriculum over the states. We then sample a state according to that curriculum and initialize our agent accordingly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            495,
+            251,
+            815,
+            362
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A popular method for improving RL with   \naccess to expert demonstrations is behavioral cloning/imitation learning. These methods explicitly encourage the learned policy to mimic an expert policy (Bain & Sommut, 1999; Ross et al., 2011; Daumé et al., 2009; Zhang & Cho, 2016; Laskey et al., 2016; Nair et al., 2017; Hester et al., 2017; Ho & Ermon, 2016; Aytar et al., 2018; Lerer & Peysakhovich, 2018; Peng et al., 2018). Imitation learning requires access to both state and expert actions (whereas Backplay only requires states) and is designed to copy an expert, thus it cannot, without further adjustments (e.g. as proposed by Gao et al. (2018)), surpass a suboptimal expert. We discuss the pros and cons of an imitation learning $^ +$ adjustment vs. a Backplay-based approach in the main analysis section. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other algorithms (Ranzato et al., 2015; Li et al., 2016; Das et al., 2017a;b), primarily in dialog, use a Backplay-like curriculum, albeit they utilize behavioral cloning for the first part of the trajectory. This is a major difference as we show that for many classes of problems, we only need to change the initial state distribution and do not see any gains from warm-starting with imitation learning. Backplay is more similar to Conservative Policy Iteration (Kakade & Langford, 2002), a theoretical paper which presents an algorithm designed to operate with an explicit restart distribution. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Also related to Backplay is the method of automatic reverse curriculum generation Florensa et al. (2017). These approaches assumes that the final goal state is known and that the environment is both resettable and reversible. The curricula are generated by taking random walks in the state space to generate starting states or by taking random actions starting at the goal state McAleer et al. (2018). These methods do not require an explicit ‘good enough’ demonstration as Backplay does. However, they require the environment to be reversible, an assumption that doesn’t hold in many realistic tasks such as a robot manipulating breakable objects or complex video games such as Starcraft. In addition, they may fare poorly when random walks reach parts of the state space that are not actually relevant for learning a good policy. Thus, whether a practitioner wants to generate curricula from a trajectory or a random walk depends on the environment’s properties. We discuss this in more detail in our analysis section and show empirical results suggesting that Backplay is superior. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hosu & Rebedea (2016) use uniformly random states of an expert demonstration as starting states for a policy. Like Backplay, they show that using a single loss function to learn a policy from both demonstrations and rewards can outperform the demonstrator and is robust to sub-optimal demonstrations. However, they do not impose a curriculum over the demonstration and are equivalent to the Uniform baseline in our experiments. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Zhu et al. (2018) use a curriculum but manually tune it for each ‘stage’ of the environment. Within each stage, they use what we call Uniform training, which fails in our most challenging environments. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Goyal et al. (2018) and Edwards et al. (2018) simultaneously proposed the use of a learned backtracking model to generate traces that lead to high value states. Their methods rely on either having the agent visit high reward states or learning a model of the environment capable of generating the states. Both of these are challenging in environments in which the dynamics near starting states are very different from those near goal states. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, Ivanovic et al. (2018) use a known (approximate) dynamics model to create a backwards curriculum for continuous control tasks. Their approach requires a physical prior which is not always available and often not applicable in multi-agent scenarios. In contrast, Backplay automatically creates a curriculum fit for any resettable environment with accompanying demonstrations. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BACKPLAY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            297,
+            273
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider the standard formalism of a single agent Markov Decision Process (MDP) defined by a set of states $s$ , a set of actions $\\mathcal { A }$ , and a transition function $\\mathcal { T } : \\mathcal { S } \\times \\mathcal { A }  \\mathcal { S }$ which gives the probability distribution of the next state given a current state and action. If $\\mathcal { P } ( A )$ denotes the space of probability distributions over actions, the agent chooses actions by sampling from a stochastic policy $\\pi : { \\mathcal { S } }  { \\mathcal { P } } ( { \\mathcal { A } } )$ , and receives reward $r : S \\times \\mathcal { A }  \\mathbb { R }$ at every time step. The agent’s goal is to construct a policy which minimizes its discounted expected return $\\begin{array} { r } { R _ { t } = \\bar { \\mathbb { E } } \\left[ \\sum _ { k = 0 } ^ { \\infty } \\bar { \\gamma } ^ { k } r _ { t + k + 1 } \\right] } \\end{array}$ where $r _ { t }$ is the reward at time $t$ and $\\gamma \\in [ 0 , 1 ]$ is the discount factor, and the expectation is taken with respect to both the policy and the environment. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The final component of an MDP is the distribution of initial starting states $s _ { 0 }$ . The key idea in demonstration which reaches a sequence of states Backplay is that we do not initialize the MDP in only a fixed $\\{ s _ { 0 } ^ { \\dot { d } } , s _ { 1 } ^ { d } , \\ldots , s _ { T } ^ { d } \\}$ $s _ { 0 }$ . Instead, we assume access to a . For each training episode, we uniformly sample starting states from the sub-sequence $\\{ s _ { T - k } ^ { d } , s _ { T - k + 1 } ^ { d } , . . . , s _ { T - j } ^ { d } \\}$ for some window $[ j , k ]$ . Note that this training regime requires the ability to reset the environment to any state. As training continues, we ‘advance’ the window according to a curriculum by increasing the values of $j$ and $k$ until we are training on the initial state in every episode $( j = k = T )$ ). In this manner, our hyperparameters for Backplay are the windows and the training epochs at which we advance them. ",
+        "bbox": [
+            173,
+            409,
+            825,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 QUANTITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            542,
+            397,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider a simple environment in which we can analytically show that Backplay will improve the sample-efficiency of RL training. ",
+        "bbox": [
+            174,
+            568,
+            823,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider a connected, undirected graph $G = ( V , E )$ . An agent is placed at a fixed node $v _ { 0 } \\in V$ and moves to neighboring nodes at a negative reward of $- 1$ for each step. Its goal is to reach a target node $v _ { * } \\in V$ , terminating the episode. This corresponds to an MDP $\\overset { \\cdot } { \\mathcal { M } } = \\overset { \\cdot } { ( } S , \\overset { \\cdot } { \\mathcal { A } } , P , R )$ with state space $s \\sim V$ , action space $A \\sim E$ , deterministic transition kernel corresponding to ",
+        "bbox": [
+            174,
+            603,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b50c512832a3a15dce66ebd525ad2553fa1273a95af194c00bad4f0b81137ce6.jpg",
+        "text": "$$\nP ( s _ { t + 1 } = j \\mid s _ { t } = i , a _ { t } = ( l , k ) ) = \\delta ( j = k ) \\delta ( l = i ) + \\delta ( j = i ) \\delta ( l \\neq i )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            667,
+            738,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and uniform reward $R ( s _ { t } , a _ { t } ) = - 1$ for $s _ { t + 1 } \\neq v _ { * }$ . Assume that $\\pi$ is a fixed policy on $\\mathcal { M }$ , such that the underlying Markov chain is irreducible and aperiodic: ",
+        "bbox": [
+            173,
+            691,
+            823,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5240147b8ae7647d482bba3a6cd99e15433d15b1e948fb029a568958d173b534.jpg",
+        "text": "$$\nK _ { \\pi } ( s ^ { \\prime } , s ) = \\sum _ { a \\in \\cal { A } } P ( s _ { t + 1 } = s ^ { \\prime } \\mid s _ { t } = s , a _ { t } = a ) \\pi ( a \\mid s )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            727,
+            681,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$K _ { \\pi }$ has a single absorbing state at $s = s _ { * } : = v _ { * }$ . Our goal is to estimate the value function of this policy, equivalent to the expected first-passage time of the Markov chain $K _ { \\pi }$ from $s _ { 0 } = s$ to $s _ { * }$ : ",
+        "bbox": [
+            171,
+            768,
+            823,
+            796
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb766041d5395b76f2147ecc46088335157716a9d463736758c6ff5fdb2b186d.jpg",
+        "text": "$$\nV _ { \\pi } ( s ) = \\mathbb { E } \\tau ( s , s _ { * } ) = \\mathbb { E } \\operatorname* { m i n } \\{ j \\geq 0 \\ ; \\ s . t . s _ { j } = s _ { * } , s _ { 0 } = s , s _ { i + 1 } \\sim K _ { \\pi } ( \\cdot , s _ { i } ) \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            803,
+            753,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider a special tractable case where the value function can be well approximated by looking at the distance of a state from the goal state. Formally: ",
+        "bbox": [
+            171,
+            835,
+            823,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1. For all $\\theta$ $\\begin{array} { r } { \\mathrm { ~ , ~ } V _ { \\theta } ( s ) = V _ { \\theta } ( s ^ { \\prime } ) \\ w h e n e \\nu e r d i s t _ { G } ( s ^ { \\prime } , s _ { \\ast } ) = d i s t _ { G } ( s , s _ { \\ast } ) . } \\end{array}$ ",
+        "bbox": [
+            173,
+            867,
+            705,
+            885
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We wish to analyze the process which is the projection of our Markov policy $\\pi$ only in terms of the distance $z _ { t }$ . However, now the transition probabilities will not only be a function of only $z _ { t }$ and so ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "this projection will be non-Markovian. Its Markov approximation $\\bar { z } _ { t }$ is defined as the Markov chain $\\overline { { K } }$ given by the expected transition probabilities ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9dcb4085f7b1680b7078da2ec6a29a1e7b6fa50bbae2f18752edc88e496e5872.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\mathrm { P r } ( \\bar { z } _ { t + 1 } = l - 1 | \\bar { z } _ { t } = l ) } } & { { = } } & { { \\alpha _ { l } : = \\mathrm { P r } _ { \\mu } ( z _ { t + 1 } = l - 1 | z _ { t } = l ) , } } \\\\ { { \\mathrm { P r } ( \\bar { z } _ { t + 1 } = l | \\bar { z } _ { t } = l ) } } & { { = } } & { { \\beta _ { l } : = \\mathrm { P r } _ { \\mu } ( z _ { t + 1 } = l | z _ { t } = l ) , l = 0 \\ldots M } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            136,
+            745,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and thus Pr(¯zt+1 = l + 1|z¯ $\\ L _ { t } = l ) = 1 - \\alpha _ { l } - \\beta _ { l } = \\operatorname* { P r } _ { \\mu } ( z _ { t + 1 } = l + 1 \\mid z _ { t } = l$ ) under the stationary distribution $\\mu$ of $K _ { \\pi }$ . ",
+        "bbox": [
+            174,
+            176,
+            825,
+            207
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2. The projected process is well described by its Markovian approximation. ",
+        "bbox": [
+            173,
+            209,
+            758,
+            224
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Though these assumptions are relatively strong, they makes the analysis of Backplay in this graph complex but analytically tractable. Given a demonstration $\\mathbf { d } = ( d _ { 0 } = s _ { 0 } , \\ldots , d _ { L } = { \\dot { s } } _ { * } )$ , $d _ { l } \\in S$ we will perform Backplay ",
+        "bbox": [
+            174,
+            234,
+            826,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. When assumptions 1 and 2 hold, the sample complexity gains from using Backplay rather than standard RL are exponential in the diameter of the graph. $\\begin{array} { r } { O ( \\frac { M ^ { 2 } } { m } \\alpha ^ { - m } ) } \\end{array}$ vs $\\Omega ( M \\alpha ^ { - M / 2 } )$ ",
+        "bbox": [
+            173,
+            281,
+            823,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3) to obtain Proof. we sample it using a step size $\\bar { d } _ { l } : = \\mathrm { d i s t } _ { G } ( \\breve { d } _ { L - m l } , s _ { * } )$ , l = 0, 1, . . . , Lm , which satisfies (such that mod $\\bar { d } _ { l } \\leq l m \\bar { }$ , where $j$ for all is defined in Section $l$ . ",
+        "bbox": [
+            169,
+            327,
+            823,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For fixed $l$ , we initialize the chain $\\overline { { K } }$ at $\\bar { d } _ { l }$ : $\\bar { z } _ { 0 } = \\bar { d } _ { l }$ . Since $\\begin{array} { r } { P r ( \\bar { z } _ { m } = 0 ) \\geq \\prod _ { j = 0 } ^ { m - 1 } \\alpha _ { j } : = \\gamma _ { 0 , m } } \\end{array}$ , after $O ( \\gamma _ { 0 , m } ^ { - 1 } )$ trials of length $\\leq M$ , we will reach the absorbing state and finally have a signal-carrying update for the Q-function at the originating state. ",
+        "bbox": [
+            173,
+            364,
+            825,
+            414
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can consequently merge that state into the absorbing state and reduce the length of the chain by one. Repeat the argument $m$ times so that after $O ( \\sum _ { j = 0 } ^ { m } \\gamma _ { j , m } ^ { - 1 } ) = O ( m \\gamma _ { 0 , m } ^ { - 1 } )$ trials, the Q-function is updated at $\\bar { z } _ { 0 }$ . Repeat at Backplay steps $\\begin{array} { r } { m , l = 1 , \\dots \\frac { M } { m } } \\end{array}$ m , and we reach a sample complexity of ",
+        "bbox": [
+            173,
+            420,
+            826,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/675de2394cb74b92ed8711877ad14c3ea27290042818d87cfedd66298a36bf7c.jpg",
+        "text": "$$\nT _ { m } = \\sum _ { k = 0 } ^ { \\frac { M } { m } - 1 } { \\cal O } \\left( M \\sum _ { j = 0 } ^ { m } \\gamma _ { k m , ( k + 1 ) m - j } ^ { - 1 } \\right) \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            473,
+            637,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the case where $\\alpha _ { l } = \\alpha$ for all $l$ , we obtain $\\gamma _ { k m , ( k + 1 ) m - j } ^ { - 1 } = \\gamma _ { 0 , m - j } = \\alpha ^ { - m + j }$ and therefore $\\begin{array} { r } { T _ { m } = O \\left( \\frac { M ^ { 2 } ( 1 - \\alpha ^ { m + 1 } ) } { m ( 1 - \\alpha ) } \\alpha ^ { - m } \\right) } \\end{array}$ , where the important term is the rate $\\textstyle { \\frac { M ^ { 2 } } { m } } \\alpha ^ { - m }$ . ",
+        "bbox": [
+            174,
+            529,
+            825,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, Hong & Zhou (2017) shows that the first-passage time $\\tau ( 0 , M )$ in a skip-free finite Markov chain of $M$ states with a single absorbing state is a random variable whose momentgenerating function $\\varphi ( s ) = \\mathbb { E } s ^ { \\tau ( s , s _ { * } ) }$ is given by ",
+        "bbox": [
+            174,
+            578,
+            825,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b04ffdf773e900e1e69ba412e144b018a452e46f1d762664056e4332b38f9da9.jpg",
+        "text": "$$\n\\varphi ( s ) = \\prod _ { j = 1 } ^ { M } \\frac { ( 1 - \\lambda _ { j } ) s } { 1 - \\lambda _ { j } s } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            627,
+            578,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { 1 } , \\dots , \\lambda _ { M }$ are the non-unit eigenvalues of the transition probability matrix. It follows that $\\begin{array} { r } { \\mathbb { E } \\tau ( 0 , M ) = \\varphi ^ { \\prime } ( 1 ) = \\sum _ { j = 1 } ^ { M } \\frac { 1 } { 1 - \\lambda _ { j } } \\approx ( 1 - \\lambda _ { 1 } ) ^ { - 1 } } \\end{array}$ , which corresponds to the reciprocal spectral gap.1 Chen & Saloff-Coste (2013) further shows that this reciprocal spectral gap is $\\Omega ( \\alpha ^ { - M / 2 } )$ in our case, and therefore the model without Backplay will on average take $T _ { M } = \\Omega ( \\alpha ^ { - M / 2 } )$ trials to reach the absorbing state and receive information. □ ",
+        "bbox": [
+            169,
+            676,
+            828,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can analyze the uniform strategy similarly. The probability that a trajectory initialized at one of the uniform samples will reach the absorbing state is lower bounded by ",
+        "bbox": [
+            173,
+            771,
+            826,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8256b601ae5dba264519cb8e48e39cbb5b66522d75c2515629ae3d734864deb2.jpg",
+        "text": "$$\n\\sum _ { j = 1 } ^ { M } \\alpha ^ { j } P ( \\bar { z } _ { 0 } = j ) = \\frac { 1 } { M } \\sum _ { j = 1 } ^ { M } \\alpha ^ { j } = \\frac { \\alpha - \\alpha ^ { M + 1 } } { M ( 1 - \\alpha ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            805,
+            655,
+            851
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which is approximately $\\frac { \\alpha } { M }$ when $\\alpha$ is small, leading to a sample complexity of $O ( M ^ { 2 } \\alpha ^ { - 1 } )$ to update the value function at the originating state, and $O ( M ^ { 3 } \\alpha ^ { - 1 } )$ at the starting state. Comparing this rate to Backplay with $m = 1$ , observe that the uniform strategy is slower by a factor of $M$ (and one can verify that the same is true for generic step size $m$ by imagining that we first sampled a window of size $m$ and then sub-sampled our state from that window), suggesting that it loses efficiency on environments with large diameter. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The preceding analysis suggests that a full characterization of Backplay is a fruitful direction for reinforcement and imitation learning theory, albeit beyond the scope of this paper. ",
+        "bbox": [
+            173,
+            166,
+            823,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 QUALITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            219,
+            387,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now provide intuition regarding the conditions under which Backplay can improve sampleefficiency or lead to a better policy than that of the demonstrator. In addition, we discuss the differences between Backplay and other methods of reducing sample complexity for deep RL as well as when practitioners would choose to use one or the other. ",
+        "bbox": [
+            173,
+            250,
+            825,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 contains three grid worlds. In each, the agent begins at $s _ { 0 }$ , receives $+ 1$ when it reaches $s _ { * }$ , and otherwise incurs a per step cost. They each pose a challenge to model free RL and highlight advantages and disadvantages of Backplay compared to other approaches like behavioral cloning (BC, Bain & Sommut (1999)), generative adversarial imitation learning (GAIL, Ho & Ermon (2016)), and reverse curriculum generation (RCG, Florensa et al. (2017)). See Table 1 for a direct comparison of these algorithms. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            395
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/80c6f889e484645e180e67926e04933eee7f28c2ac4c3c88a6bf44468b8a2017.jpg",
+        "image_caption": [
+            "Figure 2. Three environments illustrating when Backplay can help or hinder learning an optimal policy. Backplay is expected to learn faster than standard RL on the first and second mazes, but perform worse on the third maze. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            428,
+            812,
+            536
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The left grid world shows a sparse reward environment in which Backplay can decrease the requisite training time compared to standard RL. Using the sub-optimal demonstration will position the Backplay agent close to high value states. In addition, the agent will likely surpass the expert policy because, unlike in BC approaches, Backplay does not encourage the agent to imitate expert actions. Rather, the curriculum forces the agent to first explore states with large associated value and, consequently, estimating the value function suffers less from the curse of dimensionality. And finally, we expect it to also surpass results from RCG because random movements from the goal state will progress very haphazardly in such an open world. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The middle grid illustrates a maze with bottlenecks. Backplay will vastly decrease the exploration time relative to standard RL, because the agent will be less prone to exploring the errant right side chamber where it can get lost if it traverses to the right instead of going up to the goal. If we used BC, then the agent will sufficiently learn the optimal policy, however it will suffer when placed in nearby spots on the grid as they will be out of distribution; Backplay-trained agents will not have this problem as they also explore nearby states. When an RCG agent reaches the first fork, it has an even chance of exploring the right side of the grid and wasting lots of sample time. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "On the rightmost grid world, while Backplay is still likely to surpass its demonstrator, it will have trouble doing better than standard RL because the latter always starts at $s _ { 0 }$ and consequently is more likely to stumble upon the optimal solution of going up and right. In contrast, Backplay will spend the dominant amount of its early training starting in states in the sub-optimal demonstration. Note that BC will be worse off than Backplay because by learning the demonstration, it will follow the trajectory into the basin instead of going up the right side. Finally, observe that RCG will likely outperform here given that it has a high chance of discovering the left side shortcut and, if not, it would more likely discover the right side shortcut than be trapped in the basin. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In summary, Backplay is not a universal strategy to improve sample complexity. Even in the navigation setting, if the task randomizes the initial state $s _ { 0 }$ , a single demonstration trajectory does not generally improve the coverage of the state-space outside an exponentially small region around said trajectory. For example, imagine a binary tree and a navigation task that starts at a random leaf and needs to reach the root. A single expert trajectory will be disjoint from half of the state space (because the root is absorbing), thus providing no sample complexity gains on average. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c037ead3579f051fe94b1ff70602af2ebe25197b9bc15dcf8e938261647c945f.jpg",
+        "table_caption": [
+            "Table 1: Comparison of Backplay with related work: Behavioral Cloning (BC), Generative Adversarial Imitation Learning (GAIL), and Reverse Curriculum Generation (RCG). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Requirements</td><td rowspan=1 colspan=1>Main Idea</td><td rowspan=1 colspan=1>MainWeakness</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>(State,Action) pairs fromexpert trajectory.</td><td rowspan=1 colspan=1>Learn policy that imitates theexpert demonstration.</td><td rowspan=1 colspan=1>Sub-optimal expert can yield avery poor learned policy.</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>(State,Action) pairs fromexpert trajectory.</td><td rowspan=1 colspan=1>Learn a policythat matchesthe distribution of expert tra-jectory pairs.</td><td rowspan=1 colspan=1>Difficult to tune; Requires moreworld interactions; Can performworse than BC.</td></tr><tr><td rowspan=1 colspan=1>RCG</td><td rowspan=1 colspan=1>Reversable transition func-tion of environment; Reset-table environment.</td><td rowspan=1 colspan=1>Take randomwalks from goalstate to build curriculum of ini-tial starting states.</td><td rowspan=1 colspan=1>Complexitymay increase if ran-dom walks reach parts of statespace irrelevant to a good policy.</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>State sequence froma‘good enough’ trajectory;Resettable environment.</td><td rowspan=1 colspan=1>Sample starting state fromgiven trajectory by walkingbackward along trajectory.</td><td rowspan=1 colspan=1>If states in‘good enough&#x27;tra- jectory are not optimal, then canslow learning the optimal policy.</td></tr></table>",
+        "bbox": [
+            173,
+            200,
+            826,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            326,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now move to evaluating Backplay empirically in two environments: a grid world maze and a four-player free-for-all game. The questions we study across both environments are the following: ",
+        "bbox": [
+            174,
+            459,
+            826,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Is Backplay more efficient than training an RL agent from scratch? • How does the quality of the given demonstration affect the effectiveness of Backplay? • Can Backplay agents surpass the demonstrator when it is non-optimal? • Can Backplay agents generalize? ",
+        "bbox": [
+            215,
+            501,
+            797,
+            573
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            589,
+            352,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare several training regimes. The first is Backplay, which uses the Backplay algorithm corresponding to a particular sequence of windows and epochs as specified in A.1. The second, Standard is vanilla model-free RL with the agent always starting at the initial state $s _ { 0 }$ . The last, Uniform, is an ablation that considers how important is the curriculum aspect of Backplay by sampling initial states randomly from the entire demonstration. In all these regimes, we use Proximal Policy Optimization (PPO, Schulman et al. (2017)) to train an agent with policy and value functions parameterized by convolutional neural networks. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the Maze environment (detailed below), we also ran comparisons against Behavioral Cloning and Reverse Curriculum Generation. We chose BC over GAIL (Ho & Ermon, 2016) for three reasons. First, GAIL requires careful hyperparameter tuning and is thus difficult to train. Second, GAIL requires more environment interactions. And third, GAIL has recently been shown to perform significantly worse than BC (Behbahani et al., 2018). ",
+        "bbox": [
+            174,
+            719,
+            825,
+            790
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training details and network architectures for all the environments can be found in A.3 and A.6, while A.9 contains empirical observations for using Backplay in practice. ",
+        "bbox": [
+            173,
+            796,
+            823,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 MAZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            258,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We generated mazes of size $2 4 \\times 2 4$ with 120 randomly placed walls, a random start position, and a random goal position. We then used $\\mathbf { A } ^ { * }$ to generate trajectories. These included both Optimal demonstrations (true shortest path) and N-Optimal demonstrations (N steps longer than the shortest path). More details on this setup are given in A.2. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/27b82d5724c0900e7782831f13d9764e32fdadc9101ec7a75f444a6708ef6b7e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>Map Set</td><td rowspan=1 colspan=1>% Optimal</td><td rowspan=1 colspan=1>% 0-5 Optimal</td><td rowspan=1 colspan=1>Avg Suboptimality</td><td rowspan=1 colspan=1> Std Suboptimality</td></tr><tr><td rowspan=1 colspan=1>Standard</td><td rowspan=1 colspan=1>All</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>Uniform</td><td rowspan=1 colspan=1>Optimal</td><td rowspan=1 colspan=1>27</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>8.26</td><td rowspan=1 colspan=1>32.92</td></tr><tr><td rowspan=1 colspan=1>Uniform</td><td rowspan=1 colspan=1>5-Optimal</td><td rowspan=1 colspan=1>51</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>2.04</td><td rowspan=1 colspan=1>17.39</td></tr><tr><td rowspan=1 colspan=1>Uniform</td><td rowspan=1 colspan=1>10-Optimal</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>2.04</td><td rowspan=1 colspan=1>16.79</td></tr><tr><td rowspan=1 colspan=1>Florensa</td><td rowspan=1 colspan=1>Optimal</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>51</td><td rowspan=1 colspan=1>63.36</td><td rowspan=1 colspan=1>78.08</td></tr><tr><td rowspan=1 colspan=1>Florensa</td><td rowspan=1 colspan=1>5-Optimal</td><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>77</td><td rowspan=1 colspan=1>25.44</td><td rowspan=1 colspan=1>56.89</td></tr><tr><td rowspan=1 colspan=1>Florensa</td><td rowspan=1 colspan=1>10-Optimal</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>69</td><td rowspan=1 colspan=1>39.75</td><td rowspan=1 colspan=1>70.92</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>Optimal</td><td rowspan=1 colspan=1>31</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>0.64</td><td rowspan=1 colspan=1>4.96</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>5-Optimal</td><td rowspan=1 colspan=1>37</td><td rowspan=1 colspan=1>94</td><td rowspan=1 colspan=1>7.94</td><td rowspan=1 colspan=1>33.35</td></tr><tr><td rowspan=1 colspan=1>Backplay</td><td rowspan=1 colspan=1>10-Optimal</td><td rowspan=1 colspan=1>54</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>0.37</td><td rowspan=1 colspan=1>3.49</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            825,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Results after 2000 epochs on 100 mazes. Note that for Backplay and Uniform, the Map Set is also the type of demonstrator, where N-optimal has demonstrations $\\mathbf { N }$ steps longer than the shortest path. From left to right, the table shows: the percentage of mazes on which the agent optimally reaches the goal, percentage on which it reaches in at most five steps more than optimal, and the average and standard deviation of extra steps over optimal. Both Backplay and Uniform succeed on almost all mazes and, importantly, can outperform the experts’ demonstrations. On the other hand, Standard does not learn a useful policy and Florensa fails to learn more than $5 0 - 7 0 \\%$ of the maps, which is why its sub-optimality mean and std is so high. Results for Backplay were generally consistent across all seeds. For others, we report their best score. See A.4 for further details. ",
+        "bbox": [
+            173,
+            258,
+            825,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our model receives as input four $2 4 \\times 2 4$ binary maps. They contain ones at the positions of, respectively, the agent, the goal, passages, and walls. It outputs one of five options: Pass, Up, Down, Left, or Right. The game ends when the agent has reached its goal or after a maximum of 200 steps, whereupon the agent receives reward of $+ 1$ if it reaches the goal and a per step penalty of -0.03. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Backplay, Uniform, Standard. Table 2 shows that Standard has immense trouble learning in this sparse reward environment while both Backplay and Uniform find an optimal path approximately 30- $50 \\%$ of the time and a path within five of the optimal path almost always. Thus, in this environment, demonstrations of even sub-optimal experts are extremely useful, while the curriculum created by Backplay is not necessary. That curriculum does, however, aid convergence speed (A.4). We will see in 4.3 that the curriculum becomes vital as the environment increases in complexity. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Behavioral Cloning. We trained an agent using behavioral cloning from the same trajectories as the ones used for Backplay. While the agent learns to perfectly imitate those trajectories, we had immense difficult doing better than the expert. All of our attempts to use reward signal to improve the agent’s performance (over that of the behaviorally cloned agent) were unsuccessful, even after incorporating tricks in the literature such as those found in Schmitt et al. (2018). One possible reason is that the agent has no information about states outside of the demonstration trajectory. ",
+        "bbox": [
+            174,
+            559,
+            823,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Reverse Curriculum Generation. We also compared Backplay to the method proposed by Florensa et al. (2017). As illustrated in Table 2 and Section A.4, Florensa agents perform significantly worse with higher sample complexity variance compared to Backplay (or Uniform). This suggests that having demonstrations helps inordinately. Further details can be found in A.3. ",
+        "bbox": [
+            174,
+            650,
+            823,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 POMMERMAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            310,
+            737
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Pommerman is a stochastic environment (Resnick et al., 2018) based on the classic console game Bomberman and will be a competition at NeurIPS 2018. It is played on an 11x11 grid where on every turn, each of four agents either move in a cardinal direction, pass, or lay a bomb. The agents begin fenced in their own area by two different types of walls - rigid and wooden. The former are indestructible while bombs destroy the latter. Upon blowing up wooden walls, there is a uniform chance at yielding one of three power-ups: an extra bomb, an extra unit of range in the agent’s bombs, or the ability to kick bombs. The maps are designed randomly, albeit there is always a guaranteed path between any two agents. For a visual aid of the start state, see Figure 8 in A.5. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we use the purely adversarial Free-For-All (FFA) environment. This environment is introduced in (MultiAgentLearning, 2018; Resnick et al., 2018) and we point the reader there for more details. The winner of the game is the last agent standing. It is played from the perspective of one agent whose starting position is uniformly picked among the four. The three opponents are copies of the winner of the June 3rd 2018 FFA competition, a stochastic agent using a Finite State Machine Tree-Search approach (FSMTS, Zhou et al. (2018)). We also make use of the FSMTS agent as the ‘expert’ in the Backplay demonstrations. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The observation state is represented by 19 11x11 maps, and we feed the concatenated last two states to our agent as input. A detailed description of this mapping is given in A.5. The game ends either when the learning agent wins or dies, or when 800 steps have passed. Upon game end, the agent receives $+ 1$ for winning and $- 1$ otherwise (Sparse). We also run experiments where the agent additionally receives $+ 0 . 1$ whenever it collects an item (Dense). ",
+        "bbox": [
+            173,
+            152,
+            826,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fb655e834f82f1f2fc914d07474766c75d5578066da4028f1af9df41f349a66.jpg",
+        "image_caption": [
+            "Figure 3. Pommerman results (5 seeds) when training with sparse rewards. Plots a and $\\mathbf { b }$ are trained from the perspective of the winning agent, while c is trained from that of the runner up. The red bar indicates when the Backplay models begin training only on the initial state. Plot a is our starkest result and displays results on games starting from the initial state only regardless of when training occurs. you can see here that Backplay attains strong results where Uniform and Standard fail to learn anything of note. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            252,
+            843,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9075ba624117740d560bc365ca0cba6177e44e0898a5d3c9a64593cbaa86e0f3.jpg",
+        "image_caption": [
+            "Figure 4. Pommerman results (5 seeds) when training with dense rewards. Again, a and $\\mathbf { b }$ are trained from the perspective of the winning agent, while c is trained from that of the runner up. The cause of the higher variance in a was one of the seeds was worse than the others. Nonetheless, they all still did much better than either Standard or Uniform. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            505,
+            843,
+            646
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our first three scenarios follow the Sparse setup. We independently consider three Backplay trajectories, one following the winner over 100 maps, one following the winner over four maps, and one following the runner up over four maps, with the latter two set of maps being the same. Figure 3 shows that Backplay can soundly defeat the FSMTS agents in sparse settings when following the winner, even when there are 100 maps to consider, while other methods struggle in this setup. Modulo higher variance in Backplay’s result, we see a similar comparison in the runner-up case. Visit this link for an example gif of our trained Backplay agent (top left - red). Note that our agent learned to ‘throw’ bombs, a unique playing style that no prior Pommerman competitor had exhibited, including the FSMTS demonstrator. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Moreover, by training on 100 maps, Backplay generalizes (to some extent) on unseen boards. Backplay wins 416 / 1000 games on a held out set of ten maps, with the following success rates on each: $8 5 . 3 \\%$ , $8 4 . 1 \\%$ , $8 1 . 6 \\%$ , $7 9 . 5 \\%$ , $5 2 . 4 \\%$ , $4 7 . 4 \\%$ , $3 8 . 1 \\%$ , $2 2 . 6 \\%$ , $20 \\%$ , and $1 8 . 3 \\%$ . This was in contrast to our Maze experiments where no approach generalized. Given this discrepancy, we believe that the lack of generalization was a consequence of not including enough mazes during training. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have introduced and analyzed Backplay, a technique which improves the sample efficiency of model-free RL by constructing a curriculum around a demonstration. We showed that Backplay agents can learn in complex environments where standard model-free RL fails, that they can outperform the ‘expert’ whose trajectories they use while training, and that they compare very favorably to related methods such as reversible curriculum generation. We also presented a theoretical analysis of its sample complexity gains in a simplified setting. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "An important future direction is combining Backplay with more complex and complementary methods such as Monte Carlo Tree Search (MCTS, (Browne et al., 2012; Vodopivec et al., 2017)). There are many potential ways to do so, for example by using Backplay to warm-start MCTS. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            267
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another direction is to use Backplay to accelerate self-play learning in zero-sum games. However, special care needs to be taken to avoid policy correlation during training (Lanctot et al., 2017) and thus to make sure that learned strategies are safe and not exploitable (Brown & Sandholm, 2017). ",
+        "bbox": [
+            174,
+            273,
+            825,
+            315
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A third direction is towards non-zero sum games. It is well known that standard independent multiagent learning does not produce agents that are able to cooperate in social dilemmas (Leibo et al., 2017; Lerer & Peysakhovich, 2017; Peysakhovich & Lerer, 2017; Foerster et al., 2017) or risky coordination games (Yoshida et al., 2008; Peysakhovich & Lerer, 2018). In contrast, humans are much better at finding these coordinating and cooperating equilibria (Bó, 2005; Kleiman-Weiner et al., 2016). Thus, we conjecture that human demonstrations can be combined with Backplay to construct agents that perform well in such situations. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Other future priorities are to gain further understanding into when Backplay works well, when it fails, and how we can make the procedure more efficient. Could we speed up Backplay by ascertaining confidence estimates of state values? Do the gains in sample complexity come from value estimation like our analysis suggests, from policy iteration, or from both? Is there an ideal rate for advancing the curriculum window and is there a better approach than a hand-tuned schedule? ",
+        "bbox": [
+            174,
+            428,
+            825,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            285,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yusuf Aytar, Tobias Pfaff, David Budden, Tom Le Paine, Ziyu Wang, and Nando de Freitas. Playing hard exploration games by watching youtube. arXiv preprint arXiv:1805.11592, 2018.   \nMichael Bain and Claude Sommut. A framework for behavioural claning. Machine intelligence, 15 (15):103, 1999.   \nFeryal Behbahani, Kyriacos Shiarlis, Xi Chen, Vitaly Kurin, Sudhanshu Kasewa, Ciprian Stirbu, João Gomes, Supratik Paul, Frans A Oliehoek, João Messias, et al. Learning from demonstration in the wild. arXiv preprint arXiv:1811.03516, 2018.   \nPedro Dal Bó. Cooperation under the shadow of the future: experimental evidence from infinitely repeated games. American economic review, 95(5):1591–1604, 2005.   \nNoam Brown and Tuomas Sandholm. Safe and nested subgame solving for imperfect-information games. In Advances in Neural Information Processing Systems, pp. 689–699, 2017.   \nCameron B Browne, Edward Powley, Daniel Whitehouse, Simon M Lucas, Peter I Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of monte carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in games, 4(1):1–43, 2012.   \nGuan-Yu Chen and Laurent Saloff-Coste. On the mixing time and spectral gap for birth and death chains. arXiv preprint arXiv:1304.4346, 2013.   \nJ. Clark and D. Amodei. Faulty reward functions in the wild. https://blog.openai.com/ faulty-reward-functions/, 2016.   \nAbhishek Das, Samyak Datta, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Embodied question answering. CoRR, abs/1711.11543, 2017a. ",
+        "bbox": [
+            169,
+            542,
+            826,
+            926
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Das, Satwik Kottur, José M. F. Moura, Stefan Lee, and Dhruv Batra. Learning cooperative visual dialog agents with deep reinforcement learning. CoRR, abs/1703.06585, 2017b. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hal Daumé, John Langford, and Daniel Marcu. Search-based structured prediction. Machine learning, 75(3):297–325, 2009. ",
+        "bbox": [
+            171,
+            141,
+            825,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashley D Edwards, Laura Downs, and James C Davidson. Forward-backward reinforcement learning. arXiv preprint arXiv:1803.10227, 2018. ",
+        "bbox": [
+            173,
+            178,
+            825,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Carlos Florensa, David Held, Markus Wulfmeier, and Pieter Abbeel. Reverse curriculum generation for reinforcement learning. arXiv preprint arXiv:1707.05300, 2017. ",
+        "bbox": [
+            171,
+            215,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob N Foerster, Richard Y Chen, Maruan Al-Shedivat, Shimon Whiteson, Pieter Abbeel, and Igor Mordatch. Learning with opponent-learning awareness. arXiv preprint arXiv:1709.04326, 2017. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang Gao, Ji Lin, Fisher Yu, Sergey Levine, Trevor Darrell, et al. Reinforcement learning from imperfect demonstrations. arXiv preprint arXiv:1802.05313, 2018. ",
+        "bbox": [
+            171,
+            291,
+            823,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anirudh Goyal, Philemon Brakel, William Fedus, Timothy Lillicrap, Sergey Levine, Hugo Larochelle, and Yoshua Bengio. Recall traces: Backtracking models for efficient reinforcement learning. arXiv preprint arXiv:1804.00379, 2018. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Gabriel Dulac-Arnold, et al. Deep q-learning from demonstrations. arXiv preprint arXiv:1704.03732, 2017. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016. ",
+        "bbox": [
+            173,
+            431,
+            823,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wenming Hong and Ke Zhou. A note on the passage time of finite-state markov chains. Communications in Statistics-Theory and Methods, 46(1):438–445, 2017. ",
+        "bbox": [
+            174,
+            469,
+            823,
+            498
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ionel-Alexandru Hosu and Traian Rebedea. Playing atari games with deep reinforcement learning and human checkpoint replay. arXiv preprint arXiv:1607.05077, 2016. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            536
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Boris Ivanovic, James Harrison, Apoorva Sharma, Mo Chen, and Marco Pavone. Barc: Backward reachability curriculum for robotic reinforcement learning. arXiv preprint arXiv:1806.06161, 2018. ",
+        "bbox": [
+            174,
+            545,
+            826,
+            587
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In Claude Sammut and Achim G. Hoffmann (eds.), ICML, pp. 267–274. Morgan Kaufmann, 2002. ISBN 1-55860-873-7. URL http://dblp.uni-trier.de/db/conf/icml/ icml2002.html#KakadeL02. ",
+        "bbox": [
+            174,
+            597,
+            826,
+            652
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Kleiman-Weiner, Mark K Ho, Joseph L Austerweil, Michael L Littman, and Joshua B Tenenbaum. Coordinate to cooperate or compete: abstract goals and joint intentions in social interaction. In COGSCI, 2016. ",
+        "bbox": [
+            173,
+            661,
+            826,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Lanctot, Vinicius Zambaldi, Audrunas Gruslys, Angeliki Lazaridou, Julien Perolat, David Silver, Thore Graepel, et al. A unified game-theoretic approach to multiagent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 4190–4203, 2017. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Laskey, Sam Staszak, Wesley Yu-Shu Hsieh, Jeffrey Mahler, Florian T Pokorny, Anca D Dragan, and Ken Goldberg. Shiv: Reducing supervisor burden in dagger using support vectors for efficient learning from demonstrations in high dimensional state spaces. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pp. 462–469. IEEE, 2016. ",
+        "bbox": [
+            173,
+            763,
+            826,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joel Z Leibo, Vinicius Zambaldi, Marc Lanctot, Janusz Marecki, and Thore Graepel. Multi-agent reinforcement learning in sequential social dilemmas. In Proceedings of the 16th Conference on Autonomous Agents and MultiAgent Systems, pp. 464–473. International Foundation for Autonomous Agents and Multiagent Systems, 2017. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Lerer and Alexander Peysakhovich. Maintaining cooperation in complex social dilemmas using deep reinforcement learning. arXiv preprint arXiv:1707.01068, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Lerer and Alexander Peysakhovich. Learning social conventions in markov games. arXiv preprint arXiv:1806.10071, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016. URL http: //jmlr.org/papers/v17/15-522.html. ",
+        "bbox": [
+            173,
+            143,
+            826,
+            188
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiwei Li, Will Monroe, Alan Ritter, Michel Galley, Jianfeng Gao, and Dan Jurafsky. Deep reinforcement learning for dialogue generation. CoRR, abs/1606.01541, 2016. ",
+        "bbox": [
+            171,
+            199,
+            825,
+            228
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephen McAleer, Forest Agostinelli, Alexander Shmakov, and Pierre Baldi. Solving the rubik’s cube without human knowledge. arXiv preprint arXiv:1805.07470, 2018. ",
+        "bbox": [
+            171,
+            239,
+            825,
+            268
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matej Moravcík, Martin Schmid, Neil Burch, Viliam Lisý, Dustin Morrill, Nolan Bard, Trevor Davis, Kevin Waugh, Michael Johanson, and Michael H. Bowling. Deepstack: Expert-level artificial intelligence in no-limit poker. CoRR, abs/1701.01724, 2017. URL http://arxiv.org/abs/ 1701.01724. ",
+        "bbox": [
+            174,
+            280,
+            826,
+            337
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "MultiAgentLearning. Pommerman. https://github.com/MultiAgentLearning/ playground, 2018. ",
+        "bbox": [
+            174,
+            349,
+            823,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashvin Nair, Bob McGrew, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Overcoming exploration in reinforcement learning with demonstrations. arXiv preprint arXiv:1709.10089, 2017. ",
+        "bbox": [
+            176,
+            390,
+            823,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y Ng, Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, volume 99, pp. 278–287, 1999. ",
+        "bbox": [
+            176,
+            444,
+            825,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018. ",
+        "bbox": [
+            174,
+            484,
+            826,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander Peysakhovich and Adam Lerer. Consequentialist conditional cooperation in social dilemmas with imperfect information. arXiv preprint arXiv:1710.06975, 2017. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander Peysakhovich and Adam Lerer. Prosocial learning agents solve generalized stag hunts better than selfish ones. Proceedings of the 17th Conference on Autonomous Agents and MultiAgent Systems, 2018. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            623
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. CoRR, abs/1511.06732, 2015. ",
+        "bbox": [
+            173,
+            636,
+            825,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cinjon Resnick, Wes Eldridge, David Ha, Denny Britz, Jakob Foerster, Julian Togelius, Kyunghyun Cho, and Joan Bruna. Pommerman: A multi-agent playground, 2018. ",
+        "bbox": [
+            171,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stéphane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011. ",
+        "bbox": [
+            176,
+            717,
+            823,
+            761
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans and Richard Chen. Learning montezuma’s revenge from a single demonstration. https://blog.openai.com/ learning-montezumas-revenge-from-a-single-demonstration/, 2018. Accessed: 2018-07-12. ",
+        "bbox": [
+            174,
+            772,
+            826,
+            828
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Simon Schmitt, Jonathan J Hudson, Augustin Zidek, Simon Osindero, Carl Doersch, Wojciech M Czarnecki, Joel Z Leibo, Heinrich Kuttler, Andrew Zisserman, Karen Simonyan, et al. Kickstarting deep reinforcement learning. arXiv preprint arXiv:1803.03835, 2018. ",
+        "bbox": [
+            176,
+            840,
+            825,
+            883
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "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, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            103,
+            826,
+            172
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, Timothy P. Lillicrap, Karen Simonyan, and Demis Hassabis. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. CoRR, abs/1712.01815, 2017. URL http://arxiv.org/ abs/1712.01815. ",
+        "bbox": [
+            173,
+            183,
+            825,
+            252
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Vodopivec, Spyridon Samothrakis, and Branko Šter. On monte carlo tree search and reinforcement learning. J. Artif. Int. Res., 60(1):881–936, September 2017. ISSN 1076-9757. URL http://dl.acm.org/citation.cfm?id $\\equiv$ 3207692.3207712. ",
+        "bbox": [
+            174,
+            261,
+            823,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wako Yoshida, Ray J Dolan, and Karl J Friston. Game theory of mind. PLoS computational biology, 4(12):e1000254, 2008. ",
+        "bbox": [
+            173,
+            313,
+            823,
+            342
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiakai Zhang and Kyunghyun Cho. Query-efficient imitation learning for end-to-end autonomous driving. arXiv preprint arXiv:1605.06450, 2016. ",
+        "bbox": [
+            169,
+            351,
+            825,
+            381
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongwei Zhou, Yichen Gong, Luvneesh Mugrai, Ahmed Khalifa, Andy Nealen, and Julian Togelius. A hybrid search agent in pommerman. In Proceedings of the 13th International Conference on the Foundations of Digital Games, FDG ’18, pp. 46:1–46:4, New York, NY, USA, 2018. ACM. ISBN 978-1-4503-6571-0. doi: 10.1145/3235765.3235812. URL http://doi.acm.org/10. 1145/3235765.3235812. ",
+        "bbox": [
+            174,
+            388,
+            826,
+            459
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuke Zhu, Ziyu Wang, Josh Merel, Andrei A. Rusu, Tom Erez, Serkan Cabi, Saran Tunyasuvunakool, János Kramár, Raia Hadsell, Nando de Freitas, and Nicolas Heess. Reinforcement and imitation learning for diverse visuomotor skills. CoRR, abs/1802.09564, 2018. ",
+        "bbox": [
+            176,
+            468,
+            826,
+            511
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 BACKPLAY HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            441,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 3, the Backplay hyperparameters are the window bounds and the frequency with which they are shifted. When we get to a training epoch represented in the sequence of epochs, we advance to the corresponding value in the sequence of windows. For example, consider training an agent with Backplay in the Maze environment (Table 3) and assume we are at epoch 1000. We will select a maze at random, an $N \\in [ 1 6 , 3 2 )$ , and start the agent in that game $N$ steps from the end. Whenever a pair is chosen such that the game’s length is smaller than $N$ , we use the initial state. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            243
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "There isn’t any downside to having the model continue training in a window for too long, albeit the ideal is that this method increases the speed of training. There is however a downside to advancing the window too quickly. A scenario common to effective training is improving success curves punctured by step drops whenever the window advances. ",
+        "bbox": [
+            174,
+            250,
+            823,
+            305
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/8a6be69f31832deb2970bb78479fa0eebe2e7b0a040d4bda5312be024322dc3a.jpg",
+        "table_caption": [
+            "Table 3: Backplay hyperparameters for Maze. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Starting at training epoch</td><td>Uniform window</td></tr><tr><td>0</td><td>[0,4)</td></tr><tr><td>350</td><td>[4,8)</td></tr><tr><td>700</td><td>[8,16)</td></tr><tr><td>1050</td><td>[16,32)</td></tr><tr><td>1400</td><td>[32, 64)</td></tr><tr><td>1750</td><td>[64,64)</td></tr></table>",
+        "bbox": [
+            351,
+            320,
+            643,
+            415
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/0ed8e81d65175fe1716e39bddd940e7e76816035d4043833129ba8eeab411d07.jpg",
+        "table_caption": [
+            "Table 4: Backplay hyperparameters for Pommerman 4 maps. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Starting at training epoch</td><td>Uniform window</td></tr><tr><td>0</td><td>[0,32)</td></tr><tr><td>50</td><td>[24,64)</td></tr><tr><td>100</td><td>[56,128)</td></tr><tr><td>150</td><td>[120,256)</td></tr><tr><td>200</td><td>[248, 512)</td></tr><tr><td>250</td><td>[504,800)</td></tr><tr><td>300</td><td>[800,800]</td></tr></table>",
+        "bbox": [
+            351,
+            463,
+            643,
+            571
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/765f1c2d6e708bff83d8ba6d29d877092374ae5d208e02711ab7cb21132e2ff8.jpg",
+        "table_caption": [
+            "Table 5: Backplay hyperparameters for Pommerman 100 maps. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Starting at training epoch</td><td>Uniformwindow</td></tr><tr><td>0</td><td>[0,32)</td></tr><tr><td>85</td><td>[24,64)</td></tr><tr><td>170</td><td>[56,128)</td></tr><tr><td>255</td><td>[120,256)</td></tr><tr><td>340</td><td>[248,512)</td></tr><tr><td>425</td><td>[504, 800)</td></tr><tr><td>510</td><td>[800,800]</td></tr></table>",
+        "bbox": [
+            351,
+            619,
+            643,
+            728
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 MAZE: DEMONSTRATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            460,
+            787
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For N-Optimal demonstrations, we used a noisy $\\mathbf { A } ^ { * }$ where at each step, we follow $\\mathbf { A } ^ { * }$ with probability $p$ or choose a random action otherwise. We considered $N \\in \\{ 5 , 1 0 \\}$ . In all scenarios, we only selected maps in which there exists at least a path from the the initial state to the goal state, we filtered any path that was less than 35 in length and stopped when we found a hundred valid training games. Note that we held the demonstration length invariant rather than the optimal length (i.e. all N-optimal paths have the same length regardless of N, which means that the length of the optimal path of a N-optimal demonstration decreases with N). This could explain why the results in Table 2 (column 1) show that Backplay’s performance increases with $_ \\mathrm { N }$ (since the larger the N, the smaller the true optimal path, so the easier it is to learn an optimal policy for that maze configuration). ",
+        "bbox": [
+            173,
+            797,
+            826,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 MAZE: NETWORK ARCHITECTURE AND TRAINING PARAMETERS ",
+        "bbox": [
+            174,
+            103,
+            668,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use a standard deep RL setup for our agents. The agent’s policy and value functions are parameterized by a convolutional neural network with 2 layers each of 32 output channels, followed by two linear layers with 128 dimensions. Each of the layers are followed by ReLU activations. This body then feeds two heads, a scalar value function and a softmax policy function over the five actions. All of the CNN kernels are 3x3 with stride and padding of one. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            223
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We train our agent using Proximal Policy Optimization (PPO, Schulman et al. (2017)) with $\\gamma = 0 . 9 9$ , learning rate $\\mathrm { \\check { 1 } } \\times 1 0 ^ { - 3 }$ , batch size 102400, 60 parallel workers, clipping parameter 0.2, generalized advantage estimation with $\\tau = 0 . 9 5$ , entropy coefficient 0.01, value loss coefficient 0.5, mini-batch size 5120, horizon 1707, and 4 PPO updates at each iteration. The number of interactions per epoch is equal to the batch size (102400). ",
+        "bbox": [
+            174,
+            229,
+            825,
+            300
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The hyperparameters used for training the agent with Reverse Curriculum Generation (Florensa et al., 2017) are: $1 0 ^ { 4 }$ rollout states for nearby sampling, 50 Brownian steps, 200 samples from new starts, 100 samples from old starts, interval for the expected return [0.1, 0.9]. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.4 MAZE: LEARNING CURVES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            408,
+            440
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Below are our learning curves for the Maze challenge over five seeds. Note that we do not show any results for Standard as it failed to learn much of anything in the time allotted (3500 epochs). Also note that Backplay occasionally sees the actual grid starting position from epoch 1400, but it becomes the default starting state at epoch 1750. To align with this, our Florensa baseline switches to training from the actual start position at epoch 1750, and we show results for Uniform only over the initial starting state. Correspondingly, we show the graphs from epoch 1000 as all of the methods have commensurately poor results before that time. ",
+        "bbox": [
+            173,
+            476,
+            825,
+            573
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/9683ae6ed274a6f5a198d8346d1fc4c297be1738c3474374ec9f07db24dcb867.jpg",
+        "image_caption": [
+            "Figure 5. Maze results when training with demonstrations of length equal to the optimal path length. Note that Backplay has a very small variance and a very high success rate as early as epoch 1800. On the other hand, Florensa fails to break $70 \\%$ and has a high variance, and Uniform doesn’t achieve a strong success rate until epoch 3000. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            643,
+            725,
+            861
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c9d50dd06c913c8b6a47a3e64624e2b4635303e1ce588f85fbb562e7dda40ba.jpg",
+        "image_caption": [
+            "Figure 6. Maze results when training with demonstrations that are five steps longer than the optimal path length. Compared to the prior graph, Backplay doesn’t do as well, albeit it still performs favorably compared to Florensa, with a consistently higher expected return. Its advantage over Uniform is a reduced amount of necessary samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            104,
+            725,
+            320
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/27cbb6f8732e3a701353a515becbf95c1b3b9eddcd0f02bbed31cb4c37149d2e.jpg",
+        "image_caption": [
+            "Figure 7. Maze results when training with demonstrations that are ten steps longer than the optimal path length. We again see that Backplay does very well compared to the Florensa baseline, with a much stronger expected return and lower variance. We also see, however, that Uniform is an able competitor to both of these as the expert becomes more suboptimal. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            645,
+            723,
+            861
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.5 POMMERMAN: OBSERVATION STATE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            472,
+            117
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d4a42cfa8224d99a5d25bf7cf28bb43b8e5fda4938db59e2d2add13320321ab.jpg",
+        "image_caption": [
+            "Figure 8. Pommerman start state. Each agent begins in one of four positions. Yellow squares are wood, brown are rigid, and gray are passages. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            367,
+            143,
+            627,
+            343
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "There are 19 feature maps that encompass each observation. They consist of the following: the agents’ identities and locations, the locations of the walls, power-ups, and bombs, the bombs’ blast strengths and remaining life counts, and the current time step. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            448
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The first map contains the integer values of each bomb’s blast strength at the location of that bomb. The second map is similar but the integer value is the bomb’s remaining life. At all other positions, the first two maps are zero. The next map is binary and contains a single one at the agent’s location. If the agent is dead, this map is zero everywhere. The following two maps are similar. One is full with the agent’s integer current bomb count, the other with its blast radius. We then have a full binary map that is one if the agent can kick and zero otherwise. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            539
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The next maps deal with the other agents. The first contains only ones if the agent has a teammate and zeros otherwise. This is useful for building agents that can play both team and solo matches. If the agent has a teammate, the next map is binary with a one at the teammate’s location (and zero if she is not alive). Otherwise, the agent has three enemies, so the next map contains the position of the enemy that started in the diagonally opposed corner from the agent. The following two maps contain the positions of the other two enemies, which are present in both solo and team games. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            628
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We then include eight feature maps representing the respective locations of passages, rigid walls, wooden walls, flames, extra-bomb power-ups, increase-blast-strength power-ups, and kicking-ability power-ups. All are binary with ones at the corresponding locations. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            678
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Finally, we include a full map with the float ratio of the current step to the total number of steps. This information is useful for distinguishing among observation states that are seemingly very similar, but in reality are very different because the game has a fixed ending step where the agent receives negative reward for not winning. ",
+        "bbox": [
+            176,
+            685,
+            825,
+            742
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.6 POMMERMAN: NETWORK ARCHITECTURE AND TRAINING PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            720,
+            779
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We use a similar setup to that used in the Maze game. The architecture differences are that we have an additional two convolutional layers at the beginning, use 256 output channels, and have output dimensions of 1024 and 512, respectively, for the linear layers. This architecture was not tuned at all duringrate of $3 \\times 1 0 ^ { - 4 }$ of our experiments. Further hyperparameter differences are that wand a gamma of 1.0. These models trained for 72 hours, which is ${ \\sim } 5 0 \\mathrm { M }$ a learning frames. 2 ",
+        "bbox": [
+            174,
+            794,
+            825,
+            863
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/a92a40429cbdf3082c148b0c130b7d79543e398b569c02ef95298a350467e734.jpg",
+        "image_caption": [
+            "Figure 9. Typical histograms for how the Pommerman action selections change over time. From left to right are the concatenated counts of the actions (Pass, Up, Down, Left, Right, Bomb), delineated on the y-axis by the epoch. Note how the Standard agent learns to not use bombs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            141,
+            792,
+            265
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Pommerman can be difficult for reinforcement learning agents. The agent must learn to effectively wield the bomb action in order to win against competent opponents. However, bombs destroy agents indiscriminately, so placing one without knowing how to retreat often results in negative reward for that agent. Since agents begin in an isolated area, they are prone to converging to policies which do not use the bomb action (as seen in the histograms in Figure 9), which leads them to sub-optimal policies in the long-term. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            417
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.8 POMMERMAN: WIN RATES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            433,
+            406,
+            448
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Here we show the per-map win rates obtained by the agent trained with Backlpay on the 100 Pommerman maps. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            488
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/a7b76a3e658aae9b623c14629f77afa59f4f217a94992f27357dd6e84247a547.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Win</td><td rowspan=1 colspan=1>Maps</td></tr><tr><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=1>24</td></tr><tr><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>26</td></tr><tr><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>6</td></tr><tr><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>5</td></tr></table>",
+        "bbox": [
+            444,
+            501,
+            547,
+            582
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Aggregate per-map win rates of the model trained with Backplay on 100 Pommerman maps. The model was run over 5000 times in total, with at least 32 times on each of the 100 maps. The Maps column shows the number of maps on which the Backplay agent had a success rate of at least the percent in the Win column. Note that this model has a win rate of $> 8 0 \\%$ on more than half of the maps and a win rate of $> 5 0 \\%$ on all maps. ",
+        "bbox": [
+            173,
+            592,
+            826,
+            662
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.9 PRACTICAL FINDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            372,
+            695
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We trained a large number of models through our research into Backplay. Though these findings are tangential to our main points (and are mainly qualitative), we list some observations here that may be helpful for other researchers working with Backplay. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "First, we found that Backplay does not perform well when the curriculum is advanced too quickly, however it does not fail when the curriculum is advanced ‘too slowly.’ Thus, researchers interested in using Backplay should err on the side of advancing the window too slowly rather than too quickly. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            797
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Second, we found that Backplay does not need to hit a high success rate before advancing the starting state window. Initially, we tried using adaptive approaches that advanced the window when the agent reached a certain success threshold. This worked but was too slow. Our hypothesis is that what is more important is that the agent gets sufficiently exposed to enough states to attain a reasonable barometer of their value rather than that the agent learns a perfectly optimal policy for a particular set of starting states. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Third, Backplay can still recover if success goes to zero. This surprising and infrequent result occurred at the juncture where the window moved back to the initial state and even if the policy’s entropy over actions became maximal. We are unsure what differentiates these models from the ones that did not recover. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "We also explored using DAgger (Ross et al. (2011)) for training our agent, but found that it achieved approximately the same win rate $( \\sim 2 0 \\% )$ ) as what we would expect when four FSMTS agents played each other (given that there are also ties). ",
+        "bbox": [
+            174,
+            138,
+            823,
+            180
+        ],
+        "page_idx": 17
+    }
+]

parse/train/Skgb5h4KPH/Skgb5h4KPH.md

@@ -0,0 +1,597 @@
+# FREQUENCY PRINCIPLE: FOURIER ANALYSIS SHEDSLIGHT ON DEEP NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We study the training process of Deep Neural Networks (DNNs) from the Fourier analysis perspective. We demonstrate a very universal Frequency Principle (FPrinciple) — DNNs often fit target functions from low to high frequencies — on high-dimensional benchmark datasets such as MNIST/CIFAR10 and deep neural networks such as VGG16. This F-Principle of DNNs is opposite to the behavior of most conventional iterative numerical schemes (e.g., Jacobi method), which exhibit faster convergence for higher frequencies for various scientific computing problems. With theories under an idealized setting, we illustrate that this F-Principle results from the smoothness/regularity of the commonly used activation functions. The F-Principle implies an implicit bias that DNNs tend to fit training data by a low-frequency function. This understanding provides an explanation of good generalization of DNNs on most real datasets and bad generalization of DNNs on parity function or a randomized dataset.
+
+# 1 INTRODUCTION
+
+Understanding the training process of Deep Neural Networks (DNNs) is a fundamental problem in the area of deep learning. We find a common behavior of the gradient-based training process of DNNs, that is, a Frequency Principle (F-Principle):
+
+# DNNs often fit target functions from low to high frequencies during the training process.
+
+In another word, at the early stage of training, the low-frequencies are fitted and as iteration steps of training increase, the high-frequencies are fitted. For example, when a DNN is trained to fit $y = \sin ( \bar { x } ) + \sin ( 2 x )$ , its output would be close to $\sin ( x )$ at early stage and as training goes on, its output would be close to $\sin ( x ) + \sin ( 2 x )$ . F-Principle was observed empirically in synthetic low-dimensional data with MSE loss during DNN training ( $\mathrm { { X u } }$ et al., 2018; Rahaman et al., 2018). However, in deep learning, empirical phenomena could vary from one network structure to another, from one dataset to another and could exhibit significant difference between synthetic data and highdimensional real data. Therefore, the universality of the F-Principle remains an important problem for further study. Especially for high-dimensional real problems, because the computational cost of high-dimensional Fourier transform is prohibitive in practice, it is of great challenge to demonstrate the F-Principle. On the other hand, the mechanism underlying the F-Principle and its implication to the application of DNNs, e.g., design of DNN-based PDE solver, as well as their generalization ability are also important open problems to be addressed.
+
+In this work, we design two methods, i.e., projection and filtering methods, to show that the FPrinciple exists in the training process of DNNs for high-dimensional benchmarks, i.e., MNIST (LeCun, 1998), CIFAR10 (Krizhevsky et al., 2010). The settings we have considered are i) different DNN architectures, e.g., fully-connected network, convolutional neural network (CNN), and VGG16 (Simonyan & Zisserman, 2014); ii) different activation functions, e.g., tanh and rectified linear unit (ReLU); iii) different loss functions, e.g., cross entropy, mean squared error (MSE), and loss energy functional in variational problems. These results demonstrate the universality of the F-Principle.
+
+To facilitate the designs and applications of DNN-based schemes, we characterize a stark difference between DNNs and conventional numerical schemes on various scientific computing problems, where most of the conventional methods (e.g., Jacobi method) exhibit the opposite convergence behavior — faster convergence for higher frequencies. This difference implies that DNN can be adopted to accelerate the convergence of low frequencies for computational problems.
+
+We also intuitively explain with theories under an idealized setting how the smoothness/regularity of commonly used activation functions contributes to the F-Principle. Note that this mechanism is rigorously demonstrated for DNNs of general settings in a subsequent work (Luo et al., 2019). Finally, we discuss that the F-Principle provides an understanding of good generalization of DNNs in many real datasets (Zhang et al., 2016) and poor generalization in learning the parity function (Shalev-Shwartz et al., 2017; Nye & Saxe, 2018), that is, the F-Principle which implies that DNNs prefer low frequencies, is consistent with the property of low frequencies dominance in many real datasets, e.g., MNIST/CIFAR10, but is different from the parity function whose spectrum concentrates on high frequencies. Compared with previous studies, our main contributions are as follows:
+
+1. By designing both the projection and filtering methods, we consistently demonstrate the F-Principle for MNIST/CIFAR10 over various architectures such as VGG16 and various loss functions.
+
+2. For the application of solving differential equations, we show that (i) conventional numerical schemes learn higher frequencies faster whereas DNNs learn lower frequencies faster by the FPrinciple, (ii) convergence of low frequencies can be greatly accelerated with DNN-based schemes.
+
+3. We present theories under an idealized setting to illustrate how smoothness/regularity of activation function contributes to the F-Principle.
+
+4. We discuss in detail the implication of the F-Principle to the generalization of DNNs that DNNs are implicitly biased towards a low frequency function and provide an explanation of good and poor generalization of DNNs for low and high frequency dominant target functions, respectively.
+
+# 2 FREQUENCY PRINCIPLE
+
+The concept of “frequency” is central to the understanding of F-Principle. In this paper, the “frequency” means response frequency NOT image (or input) frequency as explained in the following.
+
+Image (or input) frequency (NOT used in the paper): Frequency of 2-d function $I : \mathbb { R } ^ { 2 }  \mathbb { R }$ representing the intensity of an image over pixels at different locations. This frequency corresponds to the rate of change of intensity across neighbouring pixels. For example, an image of constant intensity possesses only the zero frequency, i.e., the lowest frequency, while a sharp edge contributes to high frequencies of the image.
+
+Response frequency (used in the paper): Frequency of a general Input-Output mapping $f$ . For example, consider a simplified classification problem of partial MNIST data using only the data with label 0 and 1, $f ( x _ { 1 } , x _ { 2 } , \dot { \cdots } , x _ { 7 8 4 } ) : \mathbb { R } ^ { 7 8 4 } \to \{ 0 , 1 \}$ mapping 784-d space of pixel values to 1-d space, where $x _ { j }$ is the intensity of the $j$ -th pixel. Denote the mapping’s Fourier transform as $\hat { f } ( k _ { 1 } , k _ { 2 } , \cdots , k _ { 7 8 4 } )$ . The frequency in the coordinate $k _ { j }$ measures the rate of change of $f ( x _ { 1 } , x _ { 2 } , \cdot \cdot \cdot , x _ { 7 8 4 } )$ with respect to $x _ { j }$ , i.e., the intensity of the $j$ -th pixel. If $f$ possesses significant high frequencies for large $k _ { j }$ , then a small change of $x _ { j }$ in the image might induce a large change of the output (e.g., adversarial example). For a dataset with multiple classes, we can similarly define frequency for each output dimension. For real data, the response frequency is rigorously defined via the standard nonuniform discrete Fourier transform (NUDFT), see Appendix A.
+
+Frequency Principle: DNNs often fit target functions from low to high (response) frequencies during the training process. An illustration of F-Principle using a function of 1-d input is in Appendix B. The F-Principle is rigorously defined through the frequency defined by the Fourier transform (Appendix A, Bracewell & Bracewell (1986)) and the converging speed defined by the relative error. By using high-dimensional real datasets, we then experimentally demonstrate F-Principle at the levels of both individual frequencies (projection method) and coarse-grained frequencies (filtering method).
+
+# 3 F-PRINCIPLE IN MNIST/CIFAR10 THROUGH PROJECTION METHOD
+
+Real datasets are very different from synthetic data used in previous studies. In order to utilize the F-Principle to understand and better use DNNs in real datasets, it is important to verify whether the F-Principle also holds in high-dimensional real datasets.
+
+In thewhere ollowing experiments,is the size of dataset. mine the F-Principle in a training datasis a vector representing the image and $\{ ( \pmb { x } _ { i } , \pmb { y } _ { i } ) \} _ { i = 0 } ^ { n - 1 }$ $n$ $\pmb { x } _ { i } \in \mathbb { R } ^ { d }$ $\pmb { y } _ { i } \in \{ 0 , 1 \} ^ { 1 0 }$ output (a one-hot vector indicating the label for the dataset of image classification). $d$ is the dimension of the input $d = 7 8 4$ for MNIST and $d = 3 2 \times 3 2 \times 3$ for CIFAR10). Since the high dimensional discrete Fourier transform (DFT) requires prohibitively high computational cost, in this section, we only consider one direction in the Fourier space through a projection method for each examination.
+
+# 3.1 EXAMINATION METHOD: PROJECTION
+
+For a dataset $\{ ( \pmb { x } _ { i } , \pmb { y } _ { i } ) \} _ { i = 0 } ^ { n - 1 }$ we consider one entry of 10-d output, denoted by $y _ { i } \in \mathbb { R }$ . The high dimensional discrete non-uniform ourier transform of $\{ ( \pmb { x } _ { i } , y _ { i } ) \} _ { i = 0 } ^ { n - 1 }$ is $\begin{array} { r } { \hat { y } _ { \pmb { k } } = \frac { 1 } { n } \sum _ { i = 0 } ^ { n - 1 } y _ { i } \exp \left( - \mathrm { i } 2 \pi \pmb { k } \cdot \pmb { x } _ { i } \right) } \end{array}$ $\boldsymbol { k }$ grows exponentially on dimension $d$ . For illustration, in each examination, we consider a direction of $\boldsymbol { k }$ in the Fourier space, i.e., $\pmb { k } = k p _ { 1 } , p _ { 1 }$ is a chosen and fixed unit vector, hence |k| = k. Then we have yˆk = 1n Pn−1i=0 $\begin{array} { r } { \hat { y } _ { k } = \frac { 1 } { n } \sum _ { i = 0 } ^ { \bar { n } - 1 } y _ { i } \exp \left( - \mathrm { i } 2 \pi ( \pmb { p } _ { 1 } \cdot \pmb { x } _ { j } ) k \right) } \end{array}$ , which is essentially the 1-d Fourier transform of $\{ ( x _ { { p } _ { 1 } , i } , y _ { i } ) \} _ { i = 0 } ^ { n - 1 }$ , where $x _ { p _ { 1 } , i } = p _ { 1 } \cdot x _ { i }$ is the projection of $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ on the direction $\pmb { p } _ { 1 }$ (Bracewell $\&$ Bracewell, 1986). For each training dataset, $\pmb { p } _ { 1 }$ is chosen as the first principle component of the input space. To examine the convergence behavior of different frequency components during the training, we compute the relative difference between the DNN output and the target function for selected important frequencies $k$ ’s at each recording step, that is, $\bar { \Delta _ { F } ( k ) } = | \hat { h } _ { k } - \hat { y } _ { k } | / | \hat { y } _ { k } |$ , where $\hat { y } _ { k }$ and $\hat { h } _ { k }$ are 1-d Fourier transforms of $\{ y _ { i } \} _ { i = 0 } ^ { n - 1 }$ and the corresponding DNN output $\{ h _ { i } \} _ { i = 0 } ^ { n - 1 }$ , respectively, along ${ \pmb p } _ { 1 }$ . Note that each response frequency component, $\hat { h } _ { k }$ of DNN output evolves as the training goes.
+
+# 3.2 MNIST/CIFAR10
+
+In the following, we show empirically that the F-Principle is exhibited in the selected direction during the training process of DNNs when applied to MNIST/CIFAR10 with cross-entropy loss. The network for MNIST is a fully-connected tanh DNN (784-400-200-10) and for CIFAR10 is two ReLU convolutional layers followed by a fully-connected DNN (800-400-400-400-10). All experimental details of this paper can be found in Appendix C. We consider one of the 10-d outputs in each case using non-uniform Fourier transform. As shown in Fig. 1(a) and 1(c), low frequencies dominate in both real datasets. During the training, the evolution of relative errors of certain selected frequencies (marked by black squares in Fig. 1(a) and 1(c)) is shown in Fig. 1(b) and 1(d). One can easily observe that DNNs capture low frequencies first and gradually capture higher frequencies. Clearly, this behavior is consistent with the F-Principle. For other components of the output vector and other directions of $\pmb { p }$ , similar phenomena are also observed.
+
+![](images/c54948a38c4b0beb443d07e6968dfc4de4d4583faa2cf89f74a5c67b51d73713.jpg)  
+Figure 1: Projection method. (a, b) are for MNIST, (c, d) for CIFAR10. (a, c) Amplitude $| \hat { y } _ { k } |$ vs. frequency. Selected frequencies are marked by black squares. (b, d) $\Delta _ { F } ( k )$ vs. training epochs for the selected frequencies.
+
+# 4 F-PRINCIPLE IN MNIST/CIFAR10 THROUGH FILTERING METHOD
+
+The projection method in the previous section enables us to visualize the F-Principle in one direction for each examination at the level of individual frequency components. However, demonstration by this method alone is insufficient because it is impossible to verify the F-Principle at all potentially informative directions for high-dimensional data. To compensate the projection method, in this section, we consider a coarse-grained filtering method which is able to unravel whether, in the radially averaged sense, low frequencies converge faster than high frequencies.
+
+# 4.1 EXAMINATION METHOD: FILTERING
+
+The idea of the filtering method is as follows. We split the frequency domain into two parts, i.e., a low-frequency part with $| k | \leq k _ { 0 }$ and a high-frequency part with $| k | > k _ { 0 }$ , where $| \cdot |$ is the length of a vector. The DNN is trained as usualCIFAR10. The DNN output is denoted as y the original dataset . During the training, $\{ ( { \pmb x } _ { i } , { \pmb y } _ { i } ) \} _ { i = 0 } ^ { n - 1 }$ , such as MNIST ore the convergence of $^ { h }$ relative errors of low- and high- frequency part, using the two measures below
+
+$$
+e _ { \mathrm { l o w } } = \left( \frac { \sum _ { { \boldsymbol { k } } } \mathbb { 1 } _ { | { \boldsymbol { k } } | \leq k _ { 0 } } | \hat { y } ( { \boldsymbol { k } } ) - \hat { h } ( { \boldsymbol { k } } ) | ^ { 2 } } { \sum _ { { \boldsymbol { k } } } \mathbb { 1 } _ { | { \boldsymbol { k } } | \leq k _ { 0 } } | \hat { y } ( { \boldsymbol { k } } ) | ^ { 2 } } \right) ^ { \frac { 1 } { 2 } } , \quad e _ { \mathrm { h i g h } } = \left( \frac { \sum _ { { \boldsymbol { k } } } ( 1 - \mathbb { 1 } _ { | { \boldsymbol { k } } | \leq k _ { 0 } } ) | \hat { y } ( { \boldsymbol { k } } ) - \hat { h } ( { \boldsymbol { k } } ) | ^ { 2 } } { \sum _ { { \boldsymbol { k } } } ( 1 - \mathbb { 1 } _ { | { \boldsymbol { k } } | \leq k _ { 0 } } ) | \hat { y } ( { \boldsymbol { k } } ) | ^ { 2 } } \right) ^ { \frac { 1 } { 2 } } ,
+$$
+
+respectively, where ˆ· indicates Fourier transform, ${ \mathbb { 1 } } _ { k \leq k _ { 0 } }$ is an indicator function, i.e.,
+
+$$
+\mathbb { 1 } _ { | k | \leq k _ { 0 } } = \left\{ { \begin{array} { l l } { 1 , } & { | k | \leq k _ { 0 } , } \\ { 0 , } & { | k | > k _ { 0 } . } \end{array} } \right.
+$$
+
+If we consistently observe $e _ { \mathrm { l o w } } < e _ { \mathrm { h i g h } }$ for different $k _ { 0 }$ ’s during the training, then in a mean sense, lower frequencies are first captured by the DNN, i.e., F-Principle.
+
+However, because it is almost impossible to compute above quantities numerically due to high computational cost of high-dimensional Fourier transform, we alternatively use the Fourier transform of a Gaussian function $\hat { G } ^ { \delta } ( k )$ , where $\delta$ is the variance of the Gaussian function $G$ , to approximate $\mathbb { 1 } _ { | k | > k _ { 0 } }$ . This is reasonable due to the following two reasons. First, the Fourier transform of a Gaussian is still a Gaussian, i.e., ${ \hat { G } } ^ { \delta } ( k )$ decays exponentially as $| k |$ increases, therefore, it can approximate $\mathbb { 1 } _ { | k | \leq k _ { 0 } }$ by ${ \hat { G } } ^ { \delta } ( k )$ with a proper $\delta ( k _ { 0 } )$ (referred to as $\delta$ for simplicity). Second, the computation of $e _ { \mathrm { l o w } }$ and $e _ { \mathrm { h i g h } }$ contains the multiplication of Fourier transforms in the frequency domain, which is equivalent to the Fourier transform of a convolution in the spatial domain. We can equivalently perform the examination in the spatial domain so as to avoid the almost impossible high-dimensional Fourier transform. The low frequency part can be derived by
+
+$$
+\begin{array} { r } { \pmb { y } _ { i } ^ { \mathrm { l o w } , \delta } \triangleq ( \pmb { y } \ast \boldsymbol { G } ^ { \delta } ) _ { i } , } \end{array}
+$$
+
+where $^ *$ indicates convolution operator, and the high frequency part can be derived by
+
+$$
+\begin{array} { r } { \pmb { y } _ { i } ^ { \mathrm { h i g h } , \delta } \triangleq \pmb { y } _ { i } - \pmb { y } _ { i } ^ { \mathrm { l o w } , \delta } . } \end{array}
+$$
+
+Then, we can examine
+
+$$
+e _ { \mathrm { l o w } } = \left( \frac { \sum _ { i } | y _ { i } ^ { \mathrm { l o w } , \delta } - h _ { i } ^ { \mathrm { l o w } , \delta } | ^ { 2 } } { \sum _ { i } | y _ { i } ^ { \mathrm { l o w } , \delta } | ^ { 2 } } \right) ^ { \frac 1 2 } , \quad e _ { \mathrm { h i g h } } = \left( \frac { \sum _ { i } | y _ { i } ^ { \mathrm { h i g h } , \delta } - h _ { i } ^ { \mathrm { h i g h } , \delta } | ^ { 2 } } { \sum _ { i } | y _ { i } ^ { \mathrm { h i g h } , \delta } | ^ { 2 } } \right) ^ { \frac 1 2 } ,
+$$
+
+where $\boldsymbol { h } ^ { \mathrm { l o w } , \delta }$ and $h ^ { \mathrm { h i g h } , \delta }$ are obtained from the DNN output $^ { h }$ , which evolves as a function of training epoch, through the same decomposition. If $e _ { \mathrm { l o w } } < e _ { \mathrm { h i g h } }$ for different $\delta$ ’s during the training, F-Principle holds; otherwise, it is falsified. Next, we introduce the experimental procedure.
+
+Step One: Training. Train the DNN by the original dataset $\{ ( \pmb { x } _ { i } , \pmb { y } _ { i } ) \} _ { i = 0 } ^ { n - 1 }$ , such as MNIST or CIFAR10. $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ is an image vector, $\mathbf { \nabla } _ { \mathbf { \psi } _ { 3 } } \psi _ { i }$ is a one-hot vector.
+
+Step Two: Filtering. The low frequency part can be derived by
+
+$$
+{ \pmb y } _ { i } ^ { \mathrm { l o w } , \delta } = \frac { 1 } { C _ { i } } \sum _ { j = 0 } ^ { n - 1 } { \pmb y } _ { j } G ^ { \delta } ( { \pmb x } _ { i } - { \pmb x } _ { j } ) ,
+$$
+
+where $\begin{array} { r } { C _ { i } = \sum _ { j = 0 } ^ { n - 1 } G ^ { \delta } ( \pmb { x } _ { i } - \pmb { x } _ { j } ) } \end{array}$ is a normalization factor and
+
+$$
+G ^ { \delta } ( \pmb { x } _ { i } - \pmb { x } _ { j } ) = \exp \left( - | \pmb { x } _ { i } - \pmb { x } _ { j } | ^ { 2 } / ( 2 \delta ) \right) .
+$$
+
+The high frequency part can be derived by $\pmb { y } _ { i } ^ { \mathrm { h i g h } , \delta } \triangleq \pmb { y } _ { i } - \pmb { y } _ { i } ^ { \mathrm { l o w } , \delta }$ . We also compute $h _ { i } ^ { \mathrm { l o w } , \delta }$ and $h _ { i } ^ { \mathrm { h i g h } , \delta }$ for each DNN output $\boldsymbol { h } _ { i }$ .
+
+Step Three: Examination. To quantify the convergence of $\boldsymbol { h } ^ { \mathrm { l o w } , \delta }$ and $h ^ { \mathrm { h i g h } , \delta }$ , we compute the relative error $e _ { \mathrm { l o w } }$ and $e _ { \mathrm { h i g h } }$ at each training epoch through Eq. (3).
+
+# 4.2 DNNS WITH VARIOUS SETTINGS
+
+With the filtering method, we show the F-Principle in the DNN training process of real datasets for commonly used large networks. For MNIST, we use a fully-connected tanh-DNN (no softmax) with MSE loss; for CIFAR10, we use cross-entropy loss and two structures, one is small ReLU-CNN network, i.e., two convolutional layers, followed by a fully-connected multi-layer neural network with a softmax; the other is VGG16 (Simonyan & Zisserman, 2014) equipped with a 1024 fully-connected layer. These three structures are denoted as “DNN”, “CNN” and “VGG” in Fig. 2, respectively. All are trained by SGD from scratch. More details are in Appendix C.
+
+We scan a large range of $\delta$ for both datasets. As an example, results of each dataset for several $\delta$ ’s are shown in Fig. 2, respectively. Red color indicates small relative error. In all cases, the relative error of the low-frequency part, i.e., $e _ { \mathrm { l o w } }$ , decreases (turns red) much faster than that of the high-frequency part, i.e., $e _ { \mathrm { h i g h } }$ . Therefore, as analyzed above, the low-frequency part converges faster than the high-frequency part. We also remark that, based on the above results on cross-entropy loss, the F-Principle is not limited to MSE loss, which possesses a natural Fourier domain interpretation by the Parseval’s theorem. Note that the above results holds for both SGD and GD.
+
+![](images/0b27fb9f7b284c06ec72325d8857b6f2104077b717f26513b80570ab7b3e1dc5.jpg)  
+Figure 2: F-Principle in real datasets. $e _ { \mathrm { l o w } }$ and $e _ { \mathrm { h i g h } }$ indicated by color against training epoch.
+
+# 5 F-PRINCIPLE IN SOLVING DIFFERENTIAL EQUATION
+
+Recently, DNN-based approaches have been actively explored for a variety of scientific computing problems, e.g., solving high-dimensional partial differential equations (E et al., 2017; Khoo et al., 2017; He et al., 2018; Fan et al., 2018) and molecular dynamics (MD) simulations (Han et al., 2017). However, the behaviors of DNNs applied to these problems are not well-understood. To facilitate the designs and applications of DNN-based schemes, it is important to characterize the difference between DNNs and conventional numerical schemes on various scientific computing problems. In this section, focusing on solving Poisson’s equation, which has broad applications in mechanical engineering and theoretical physics (Evans, 2010), we highlight a stark difference between a DNN-based solver and the Jacobi method during the training/iteration, which can be explained by the F-Principle.
+
+Consider a 1-d Poisson’s equation:
+
+$$
+\begin{array} { r l } & { - \Delta u ( x ) = g ( x ) , \quad x \in \Omega \triangleq ( - 1 , 1 ) , } \\ & { u ( - 1 ) = u ( 1 ) = 0 . } \end{array}
+$$
+
+We consider the example with $g ( x ) = \sin ( x ) + 4 \sin ( 4 x ) - 8 \sin ( 8 x ) + 1 6 \sin ( 2 4 x )$ which has analytic solution $u _ { \mathrm { r e f } } ( x ) = g _ { 0 } ( x ) + c _ { 1 } x + c _ { 0 }$ , where $g _ { 0 } = \sin ( x ) + \sin ( 4 x ) / 4 - \sin ( 8 x ) / 8 + \sin ( 2 4 x ) / 3 6 ,$ $c _ { 1 } = ( g _ { 0 } ( - 1 ) - g _ { 0 } ( 1 ) ) / 2$ and $c _ { 0 } = - ( g _ { 0 } ( - 1 ) + g _ { 0 } ( 1 ) ) / 2$ . 1001 training samples $\{ x _ { i } \} _ { i = 0 } ^ { n }$ are evenly spaced with grid size $\delta x$ in $[ 0 , 1 ]$ . Here, we use the DNN output, $h ( x ; \theta )$ , to fit $u _ { \mathrm { r e f } } ( x )$ (Fig. 3(a)). A
+
+![](images/d241587fe6788ba5fc40badbaf0930d66b995bddd30fe42326b0cf999c5935ad.jpg)  
+Figure 3: Poisson’s equation. (a) $u _ { \mathrm { r e f } } ( x )$ . Inset: $| \hat { u } _ { \mathrm { r e f } } ( k ) |$ as a function of frequency. Frequencies peaks are marked with black dots. (b,c) $\Delta _ { F } ( k )$ computed on the inputs of training data at different epochs for the selected frequencies for DNN (b) and Jacobi (c). (d) $\| h - u _ { \mathrm { r e f } } \| _ { \infty }$ at different running time. Green stars indicate $\| h - u _ { \mathrm { r e f } } \| _ { \infty }$ using DNN alone. The dashed lines indicate $\| h - u _ { \mathrm { r e f } } \| _ { \infty }$ for the Jacobi method with different colors indicating initialization by different timing of DNN training.
+
+DNN-based scheme is proposed by considering the following empirical loss function (E & Yu, 2018),
+
+$$
+I _ { \mathrm { e m p } } = \sum _ { i = 1 } ^ { n - 1 } \left( \frac { 1 } { 2 } | \nabla _ { x } h ( x _ { i } ) | ^ { 2 } - g ( x _ { i } ) h ( x _ { i } ) \right) \delta x + \beta \left( h ( x _ { 0 } ) ^ { 2 } + h ( x _ { n } ) ^ { 2 } \right) .
+$$
+
+The second term in $I _ { \mathrm { e m p } } ( h )$ is a penalty, with constant $\beta$ , arising from the Dirichlet boundary condition (7). After training, the DNN output well matches the analytical solution $u _ { \mathrm { r e f } }$ . Focusing on the convergence of three peaks (inset of Fig. 3(a)) in the Fourier transform of $u _ { \mathrm { r e f } }$ , as shown in Fig. 3(b), low frequencies converge faster than high frequencies as predicted by the F-Principle. For comparison, we also use the Jacobi method to solve problem (6). High frequencies converge faster in the Jacobi method (Details can be found in Appendix D), as shown in Fig. 3(c).
+
+As a demonstration, we further propose that DNN can be combined with conventional numerical schemes to accelerate the convergence of low frequencies for computational problems. First, we solve the Poisson’s equation in Eq. (6) by DNN with $M$ optimization steps (or epochs), which needs to be chosen carefully, to get a good initial guess in the sense that this solution has already learned the low frequencies (large eigenvalues) part. Then, we use the Jacobi method with the new initial data for the further iterations. We use $\begin{array} { r } { \| h - u _ { \mathrm { r e f } } \| _ { \infty } \triangleq \operatorname* { m a x } _ { x \in \Omega } | h ( x ) - u _ { \mathrm { r e f } } ( x ) | } \end{array}$ to quantify the learning result. As shown by green stars in Fig. 3(d), $\| h - u _ { \mathrm { r e f } } \| _ { \infty }$ fluctuates after some running time using DNN only. Dashed lines indicate the evolution of the Jacobi method with initial data set to the DNN output at the corresponding steps. If $M$ is too small (stop too early) (left dashed line), which is equivalent to only using Jacobi, it would take long time to converge to a small error, because low frequencies converges slowly, yet. If $M$ is too big (stop too late) (right dashed line), which is equivalent to using DNN only, much time would be wasted for the slow convergence of high frequencies. A proper choice of $M$ is indicated by the initial point of orange dashed line, in which low frequencies are quickly captured by the DNN, followed by fast convergence in high frequencies of the Jacobi method.
+
+This example illustrates a cautionary tale that, although DNNs has clear advantage, using DNNs alone may not be the best option because of its limitation of slow convergence at high frequencies. Taking advantage of both DNNs and conventional methods to design faster schemes could be a promising direction in scientific computing problems.
+
+# 6 A PRELIMINARY THEORETICAL UNDERSTANDING
+
+A subsequent theoretical work (Luo et al., 2019) provides a rigorous mathematical study of the FPrinciple at different frequencies for general DNNs (e.g., multiple hidden layers, different activation functions, high-dimensional inputs). The key insight is that the regularity of DNN converts into the decay rate of a loss function in the frequency domain. For an intuitive understanding of this key insight, we present theories under an idealized setting, which connect the smoothness/regularity of the activation function with different gradient and convergence priorities in frequency domain.
+
+The activation function we consider is $\sigma ( x ) = \operatorname { t a n h } ( x )$ , which is smooth in spatial domain and its derivative decays exponentially with respect to frequency in the Fourier domain. For a DNN of one hidden layer with $m$ nodes, 1-d input $x$ and 1-d output: $\begin{array} { r } { h ( x ) = \sum _ { j = 1 } ^ { m } a _ { j } \sigma ( w _ { j } x + b _ { j } ) , \quad a _ { j } , w _ { j } , b _ { j } \in \sigma } \end{array}$ $\mathbb { R }$ . We also use the notation $\theta = \left\{ \theta _ { l j } \right\}$ with $\theta _ { 1 j } = a _ { j }$ , $\theta _ { 2 j } = w _ { j }$ , and $\theta _ { 3 j } = b _ { j }$ , $j = 1 , \cdots , m$ . The loss at frequency $k$ is $\begin{array} { r } { L ( k ) = \frac { 1 } { 2 } \left| \hat { h } ( k ) - \hat { f } ( k ) \right| ^ { 2 } } \end{array}$ , ˆ· is the Fourier transform, $f$ is the target function. The total loss function is defined as: this loss function in the Fourier do $\begin{array} { r } { L = \int _ { - \infty } ^ { + \infty } L ( k ) \mathrm { d } k } \end{array}$ . Note that according to Parseval’s theorem,e commonly used MSE loss. We have the following theorems (The proofs are at Appendix E.). Define $W = ( w _ { 1 } , w _ { 2 } , \cdot \cdot \cdot , w _ { m } ) ^ { T } \in \mathbb { R } ^ { m }$ .
+
+Theorem 1. Considering a DNN of one hidden layer with activation function $\sigma ( x ) = \operatorname { t a n h } ( x )$ , for any frequencies $k _ { 1 }$ and $k _ { 2 }$ such that $| { \hat { f } } ( k _ { 1 } ) | > 0$ , $| { \hat { f } } ( k _ { 2 } ) | > 0 ;$ , and $| k _ { 2 } | > | k _ { 1 } | > 0 ;$ , there exist positive constants c and $C$ such that for sufficiently small $\delta$ , we have
+
+$$
+\frac { \mu ( \{ W : | \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } | > | \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } |    f o r a l l \quad l , j \} \cap B _ { \delta } ) } { \mu ( B _ { \delta } ) } \geq 1 - C \exp ( - c / \delta ) ,
+$$
+
+where $B _ { \delta } \subset \mathbb { R } ^ { m }$ is a ball with radius $\delta$ centered at the origin and $\mu ( \cdot )$ is the Lebesgue measure.
+
+Theorem 1 indicates that for any two non-converged frequencies, with small weights, the lowerfrequency gradient exponentially dominates over the higher-frequency ones. Due to Parseval’s theorem, the MSE loss in the spatial domain is equivalent to the L2 loss in the Fourier domain. To intuitively understand the higher decay rate of a lower-frequency loss function, we consider the training in the Fourier domain with loss function of only two non-zero frequencies.
+
+Theorem 2. Considering a DNN of one hidden layer with activation function $\sigma ( x ) = \operatorname { t a n h } ( x )$ . Suppose the target function has only two non-zero frequencies $k _ { 1 }$ and $k _ { 2 }$ , that is, $| { \hat { f } } ( k _ { 1 } ) | > 0$ , $| \hat { f } ( k _ { 2 } ) | > 0$ , $| k _ { 2 } | > | k _ { 1 } | > 0$ , and $| { \hat { f } } ( k ) | = 0$ for $\boldsymbol { k } \neq k _ { 1 } , k _ { 2 }$ . Consider the loss function of $L = L ( k _ { 1 } ) + L ( k _ { 2 } )$ with gradient descent training. Denote
+
+$$
+\mathcal { S } = \left\{ \frac { \partial L ( k _ { 1 } ) } { \partial t } \leq 0 , \frac { \partial L ( k _ { 1 } ) } { \partial t } \leq \frac { \partial L ( k _ { 2 } ) } { \partial t } \right\} ,
+$$
+
+that is, $L ( k _ { 1 } )$ decreases faster than $L ( k _ { 2 } )$ . There exist positive constants c and $C$ such that for sufficiently small $\delta$ , we have
+
+$$
+\frac { \mu \left( \left\{ W : { \cal S } \mathrm {  ~ \ h o l d s } \right\} \cap { \cal B } _ { \delta } \right) } { \mu ( { \cal B } _ { \delta } ) } \geq 1 - C \exp ( - c / \delta ) ,
+$$
+
+where $B _ { \delta } \subset \mathbb { R } ^ { m }$ is a ball with radius $\delta$ centered at the origin and $\mu ( \cdot )$ is the Lebesgue measure.
+
+# 7 DISCUSSIONS
+
+DNNs often generalize well for real problems (Zhang et al., 2016) but poorly for problems like fitting a parity function (Shalev-Shwartz et al., 2017; Nye & Saxe, 2018) despite excellent training accuracy for all problems. Understanding the differences between above two types of problems, i.e., good and bad generalization performance of DNN, is critical. In the following, we show a qualitative difference between these two types of problems through Fourier analysis and use the $F$ -Principle to provide an explanation different generalization performances of DNNs.
+
+For MNIST/CIFAR10, we examine $\begin{array} { r l r } { \hat { y } _ { \mathrm { t o t a l } , k } } & { = } & { \frac { 1 } { n _ { \mathrm { t o t a l } } } \sum _ { i = 0 } ^ { n _ { \mathrm { t o t a l } } - 1 } y _ { i } \exp \left( - \mathrm { i } 2 \pi \pmb { k } \cdot \pmb { x } _ { i } \right) } \end{array}$ , where $\{ ( { \pmb x } _ { i } , y _ { i } ) \} _ { i = 0 } ^ { n _ { \mathrm { t o t a l } } - 1 }$ consists of both the training and test datasets with certain selected output component, at different directions of in the Fourier space. We find that $\hat { y } _ { \mathrm { t o t a l } , k }$ concentrates on the low frequencies along those examined directions. For illustration, $\hat { y } _ { \mathrm { t o t a l } , k }$ ’s along the first principle component are shown by green lines in Fig. 4(a, b) for MNIST/CIFAR10, respectively. When only the training dataset is used, $\hat { y } _ { \mathrm { t r a i n } , k }$ well overlaps with $\hat { y } _ { \mathrm { t o t a l } , k }$ at the dominant low frequencies.
+
+For the parity function $\begin{array} { r } { f ( \pmb { x } ) = \prod _ { j = 1 } ^ { d } x _ { j } } \end{array}$ defined on $\Omega = \{ - 1 , 1 \} ^ { d }$ , its Fourier transform is ${ \hat { f } } ( \pmb { k } ) =$ $\begin{array} { r } { \frac { 1 } { 2 ^ { d } } \sum _ { x \in \Omega } \prod _ { j = 1 } ^ { d } x _ { j } \mathrm { e } ^ { - \mathrm { i } 2 \pi k \cdot x } = ( - \mathrm { i } ) ^ { d } \prod _ { j = 1 } ^ { d } \sin 2 \pi k _ { j } } \end{array}$ . Clearly, for $\pmb { k } \in [ - \frac { 1 } { 4 } , \frac { 1 } { 4 } ] ^ { d }$ , the power of the parity function concentrates at $k \in \{ - \frac { 1 } { 4 } , \frac { 1 } { 4 } \} ^ { d }$ and vanishes as $\mathbf k \to \mathbf 0$ , as illustrated in Fig. 4(c) for the direction of ${ \bf 1 } _ { d }$ . Given a randomly sampled training dataset $S \subset \Omega$ with $s$ points, the nonuniform
+
+![](images/052ee35d5ce055c3e7ff406efd4d14ade183f5977328a1c15075fd3146c67605.jpg)  
+Figure 4: Fourier analysis for different generalization ability. The plot is the amplitude of the Fourier coefficient against frequency $k$ . The red dots are for the training dataset, the green line is for the whole dataset, and the blue dashed line is for an output of well-trained DNN on the input of the whole dataset. For (c), $d = 1 0$ . The training data is 200 randomly selected points.
+
+Fourier transform on $S$ is computed as $\begin{array} { r } { \hat { f } _ { S } ( \pmb { k } ) = \frac { 1 } { s } \sum _ { \pmb { x } \in S } \prod _ { j = 1 } ^ { d } x _ { j } \mathrm { e } ^ { - \mathrm { i } 2 \pi \pmb { k } \cdot \pmb { x } } } \end{array}$ . As shown in Fig. 4(c), ${ \hat { f } } ( \pmb { k } )$ and ${ \hat { f } } _ { S } ( { k } )$ significantly differ at low frequencies.
+
+By experiments, the generalization ability of DNNs can be well reflected by the Fourier analysis. For the MNIST/CIFAR10, we observed the Fourier transform of the output of a well-trained DNN on $\{ \pmb { x } _ { i } \} _ { i = 0 } ^ { n _ { \mathrm { t o t a l } } - 1 }$ faithfully recovers the dominant low frequencies, as illustrated in Fig. 4(a) and 4(b), indicating a good generalization performance as observed in experiments. However, for the parity function, we observed that the Fourier transform of the output of a well-trained DNN on $\{ { \pmb x } _ { i } \} _ { i \in S }$ significantly deviates from ${ \hat { f } } ( \pmb { k } )$ at almost all frequencies, as illustrated in Fig. 4(c), indicating a bad generalization performance as observed in experiments.
+
+The F-Principle implicates that among all the functions that can fit the training data, a DNN is implicitly biased during the training towards a function with more power at low frequencies. If the target function has significant high-frequency components, insufficient training samples will lead to artificial low frequencies in training dataset (see red line in Fig. 4(c)), which is the wellknown aliasing effect. Based on the F-Principle, as demonstrated in Fig. 4(c), these artificial low frequency components will be first captured to explain the training samples, whereas the high frequency components will be compromised by DNN. For MNIST/CIFAR10, since the power of high frequencies is much smaller than that of low frequencies, artificial low frequencies caused by aliasing can be neglected. To conclude, the distribution of power in Fourier domain of above two types of problems exhibits significant differences, which result in different generalization performances of DNNs according to the F-Principle.
+
+# 8 RELATED WORK
+
+There are different approaches attempting to explain why DNNs often generalize well. For example, generalization error is related to various complexity measures (Bartlett et al., 1999; Neyshabur et al., 2017; E et al., 2018), local properties (sharpness/flatness) of loss functions at minima (Keskar et al., 2016; Wu et al., 2017), stability of optimization algorithms (Hardt et al., 2015), and implicit bias of the training process (Soudry et al., 2018; Arpit et al., 2017; Xu et al., 2018). On the other hand, several works focus on the failure of DNNs (Shalev-Shwartz et al., 2017; Nye & Saxe, 2018), e.g., fitting the parity function, in which a well-trained DNN possesses no generalization ability. We propose that the Fourier analysis can provide insights into both success and failure of DNNs.
+
+F-Principle was first discovered in (Xu et al., 2018; Rahaman et al., 2018) simultaneously through simple synthetic data and not very deep networks. In the revised version, Rahaman et al. (2018) examines the F-Principle in the MNIST dataset. However, they add noise to MNIST, which contaminates the labels and damages the structure of real data. They only examine not very deep (6-layer) fully connected ReLU network with MSE loss, while cross-entropy loss is widely used. This paper verified that F-Principle holds in the training process of MNIST and CIFAR10, both CNN and fully connected networks, very deep networks (VGG16) and various loss functions, e.g., MSE Loss, cross-entropy loss and variational loss function. In the aspect of theoretical study, based on the key mechanism found by the theoretical study in this paper, Luo et al. (2019) shows a rigorous proof of the F-Principle for general DNNs. The theoretical study of the gradient of $\operatorname { t a n h } ( x )$ in the Fourier domain is adopted by Rahaman et al. (2018), in which they generalize the analysis to ReLU and show similar results. Thm 1 is also used to analyze a nonlinear collaborative scheme for deep network training (Zhen et al., 2018). In the aspect of application, based on the study of the F-Principle in this paper, Cai et al. (2019) and Cai & Xu (2019) design DNN-based algorithms to solve high-dimensional and high-frequency problems.
+
+# REFERENCES
+
+Devansh Arpit, Stanislaw Jastrzebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S Kanwal, Tegan Maharaj, Asja Fischer, Aaron Courville, Yoshua Bengio, et al. A closer look at memorization in deep networks. arXiv preprint arXiv:1706.05394, 2017. 8
+
+Peter L Bartlett, Vitaly Maiorov, and Ron Meir. Almost linear vc dimension bounds for piecewise polynomial networks. In Advances in Neural Information Processing Systems, pp. 190–196, 1999. 8
+
+Ronald Newbold Bracewell and Ronald N Bracewell. The Fourier transform and its applications, volume 31999. McGraw-Hill New York, 1986. 2, 3.1
+
+Wei Cai and Zhi-Qin John Xu. Multi-scale deep neural networks for solving high dimensional pdes. arXiv preprint arXiv:1910.11710, 2019. 8
+
+Wei Cai, Xiaoguang Li, and Lizuo Liu. A phase shift deep neural network for high frequency wave equations in inhomogeneous media. Arxiv preprint, arXiv:1909.11759, 2019. 8
+
+Weinan E and Bing Yu. The deep ritz method: A deep learning-based numerical algorithm for solving variational problems. Communications in Mathematics and Statistics, 6(1):1–12, 2018. 5
+
+Weinan E, Jiequn Han, and Arnulf Jentzen. Deep learning-based numerical methods for highdimensional parabolic partial differential equations and backward stochastic differential equations. Communications in Mathematics and Statistics, 5(4):349–380, 2017. 5
+
+Weinan E, Chao Ma, and Lei Wu. A priori estimates of the generalization error for two-layer neural networks. arXiv preprint arXiv:1810.06397, 2018. 8
+
+Lawrence C Evans. Partial differential equations. 2010. 5
+
+Yuwei Fan, Lin Lin, Lexing Ying, and Leonardo Zepeda-Nunez. A multiscale neural network based ´ on hierarchical matrices. arXiv preprint arXiv:1807.01883, 2018. 5
+
+Jiequn Han, Linfeng Zhang, Roberto Car, et al. Deep potential: A general representation of a many-body potential energy surface. arXiv preprint arXiv:1707.01478, 2017. 5
+
+Moritz Hardt, Benjamin Recht, and Yoram Singer. Train faster, generalize better: Stability of stochastic gradient descent. arXiv preprint arXiv:1509.01240, 2015. 8
+
+Juncai He, Lin Li, Jinchao Xu, and Chunyue Zheng. Relu deep neural networks and linear finite elements. arXiv preprint arXiv:1807.03973, 2018. 5
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. 8
+
+Yuehaw Khoo, Jianfeng Lu, and Lexing Ying. Solving parametric pde problems with artificial neural networks. arXiv preprint arXiv:1707.03351, 2017. 5
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. C, 6
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). URL http://www. cs. toronto. edu/kriz/cifar. html, 2010. 1
+
+Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998. 1
+
+Tao Luo, Zheng Ma, Zhi-Qin John Xu, and Yaoyu Zhang. Theory of the frequency principle for general deep neural networks. arXiv preprint arXiv:1906.09235, 2019. 1, 6, 8
+
+Behnam Neyshabur, Srinadh Bhojanapalli, David McAllester, and Nati Srebro. Exploring generalization in deep learning. In Advances in Neural Information Processing Systems, pp. 5947–5956, 2017. 8
+
+Maxwell Nye and Andrew Saxe. Are efficient deep representations learnable? 2018. 1, 7, 8
+
+Nasim Rahaman, Devansh Arpit, Aristide Baratin, Felix Draxler, Min Lin, Fred A Hamprecht, Yoshua Bengio, and Aaron Courville. On the spectral bias of deep neural networks. arXiv preprint arXiv:1806.08734, 2018. 1, 8, B
+
+Shai Shalev-Shwartz, Ohad Shamir, and Shaked Shammah. Failures of gradient-based deep learning. arXiv preprint arXiv:1703.07950, 2017. 1, 7, 8
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. 1, 4.2
+
+Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The implicit bias of gradient descent on separable data. Journal of Machine Learning Research, 19(70), 2018. 8
+
+Lei Wu, Zhanxing Zhu, and Weinan E. Towards understanding generalization of deep learning: Perspective of loss landscapes. arXiv preprint arXiv:1706.10239, 2017. 8
+
+Zhi-Qin J Xu, Yaoyu Zhang, and Yanyang Xiao. Training behavior of deep neural network in frequency domain. arXiv preprint arXiv:1807.01251, 2018. 1, 8, B
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016. 1, 7
+
+Hui-Ling Zhen, Xi Lin, Alan Z Tang, Zhenhua Li, Qingfu Zhang, and Sam Kwong. Nonlinear collaborative scheme for deep neural networks. arXiv preprint arXiv:1811.01316, 2018. 8
+
+A RESPONSE FREQUENCY OF TRAINING DATA $\{ y _ { i } \} _ { i = 0 } ^ { n - 1 }$ ON INPUTS $\{ { \pmb x } _ { i } \} _ { i = 0 } ^ { n - 1 }$
+
+In all our experiments, we consistently consider the response frequency defined for the mapping function $g$ between inputs and outputs, say $\mathbb { R } ^ { d } \to \mathbb { R }$ and any $\pmb { k } \in \bar { \mathbb { R } } ^ { d }$ via the standard nonuniform discrete Fourier transform (NUDFT)
+
+$$
+\hat { g } _ { \pmb { k } } = \frac { 1 } { n } \sum _ { i = 0 } ^ { n - 1 } g ( \pmb { x } _ { i } ) \mathrm { e } ^ { - \mathrm { i } 2 \pi \pmb { k } \cdot \pmb { x } _ { i } } ,
+$$
+
+which is a natural estimator of frequency composition of $g$ . (More details can be found in https: $/ / { \mathrm { e n } }$ .wikipedia.org/wiki/Non-uniform_discrete_Fourier_transform.) As $n \to \infty$ , $\begin{array} { r } { { \hat { g } } _ { \pmb { k } } \overset { \cdot } {  } \int g ( \pmb { x } ) \mathrm { e } ^ { - \mathrm { i } \overline { { 2 } } \pi \pmb { k } \cdot \pmb { x } } \nu ( \pmb { x } ) \mathrm { d } \pmb { x } } \end{array}$ , where $\nu ( { \pmb x } )$ is the data distribution.
+
+We restrict all the evaluation of Fourier transform in our experiments to NUDFT of $\{ { \bf { y } } _ { i } \} _ { i = 0 } ^ { n - 1 }$ at $\{ { \pmb x } _ { i } \} _ { i = 0 } ^ { n - 1 }$ for the following practical reasons.
+
+(i) The information of target function is only available at $\{ { \pmb x } _ { i } \} _ { i = 0 } ^ { n - 1 }$ for training.
+
+(ii) It allows us to perform the convergence analysis. As $t  \infty$ , in general, $h ( \pmb { x } _ { i } , t )  \pmb { y } _ { i }$ for any $i$ $( h ( x _ { i } , t )$ is the DNN output), leading to $\hat { h } _ { k }  \hat { y } _ { k }$ for any $\boldsymbol { k }$ . Therefore, we can analyze the convergence at different $\boldsymbol { k }$ by evaluating $\Delta _ { F } ( { \boldsymbol { k } } ) = | \hat { h } _ { \boldsymbol { k } } - \hat { y } _ { \boldsymbol { k } } | / | \hat { y } _ { \boldsymbol { k } } |$ during the training. If we use a different set of data points for frequency evaluation of DNN output, then $\Delta _ { F } ( k )$ may not converge to 0 at the end of training.
+
+(iii) $\hat { y } _ { k }$ faithfully reflect the frequency structure of training data $\{ { \pmb x } _ { i } , { \pmb y } _ { i } \} _ { i = 0 } ^ { n - 1 }$ . Intuitively, high frequencies of $\hat { y } _ { k }$ correspond to sharp changes of output for some nearby points in the training data. Then, by applying a Gaussian filter and evaluating still at $\{ { \pmb x } _ { i } \} _ { i = 0 } ^ { n - 1 }$ , we obtain the low frequency part of training data with these sharp changes (high frequencies) well suppressed.
+
+![](images/6219e31bb9843da14549f41ae1b001786788bab17c1e47f5f50efbe39c5dd9b7.jpg)  
+Figure 5: 1d input. (a) $f ( x )$ . Inset : $| { \hat { f } } ( k ) |$ . (b) $\Delta _ { F } ( k )$ of three important frequencies (indicated by black dots in the inset of (a)) against different training epochs.
+
+In practice, it is impossible to evaluate and compare the convergence of all $\boldsymbol { k } \in \mathbb { R } ^ { d }$ even with a proper cutoff frequency for a very large $d$ of $O ( 1 0 ^ { \bar { 2 } } )$ (MNIST) or $\bar { O } ( 1 0 ^ { 3 } )$ (CIFAR10) due to curse of dimensionality. Therefore, we propose the projection approach, i.e., fixing $\boldsymbol { k }$ at a specific direction and the filtering approach as detailed in Section 3 and 4, respectively.
+
+# B ILLUSTRATION OF F-PRINCIPLE FOR 1-D SYNTHETIC DATA
+
+To illustrate the phenomenon of F-Principle, we use 1-d synthetic data to show the evolution of relative training error at different frequencies during the training of DNN. we train a DNN to fit a 1-d target function $f ( x ) = \sin ( x ) + \sin ( 3 x ) + \sin ( 5 x )$ of three frequency components. On $n = 2 0 1$ evenly spaced training samples, i.e., $\{ x _ { i } \} _ { i = 0 } ^ { n - 1 }$ in $[ - 3 . 1 4 , 3 . 1 4 ]$ , the discrete Fourier transform (DFT) of $f ( x )$ or the DNN output (denoted by $h ( x ) _ { , } ^ { \cdot }$ ) is computed by $\begin{array} { r } { \hat { f } _ { k } = \frac { 1 } { n } \sum _ { i = 0 } ^ { n - 1 } f ( x _ { i } ) \mathrm { e } ^ { - \mathrm { i } 2 \pi i k / n } } \end{array}$ and $\begin{array} { r } { \hat { h } _ { k } = \frac { 1 } { n } \sum _ { i = 0 } ^ { n - 1 } h ( x _ { i } ) \mathrm { e } ^ { - \mathrm { i } 2 \pi j k / n } } \end{array}$ , where $k$ is the frequency. As shown in Fig. 5(a), the target function has three important frequencies as we design (black dots at the inset in Fig. 5(a)). To examine the convergence behavior of different frequency components during the training with MSE, we compute the relative difference between the DNN output and the target function for the three important frequencies $k$ ’s at each recording step, that is, $\bar { \Delta } _ { F } ( k ) = { | \hat { h } _ { k } - \hat { f } _ { k } | } / { | \hat { f } _ { k } | }$ , where $| \cdot |$ denotes the norm of a complex number. As shown in Fig. 5(b), the DNN converges the first frequency peak very fast, while converging the second frequency peak much slower, followed by the third frequency peak.
+
+Next, we investigate the F-Principle on real datasets with more general loss functions other than MSE which was the only loss studied in the previous works ( $\mathrm { { X u } }$ et al., 2018; Rahaman et al., 2018). All experimental details can be found in Appendix. C.
+
+# C EXPERIMENTAL SETTINGS
+
+In Fig. 5, the parameters of the DNN is initialized by a Gaussian distribution with mean 0 and standard deviation 0.1. We use a tanh-DNN with widths 1-8000-1 with full batch training. The learning rate is 0.0002. The DNN is trained by Adam optimizer (Kingma & Ba, 2014) with the MSE loss function.
+
+In Fig. 1, for MNIST dataset, the training process of a tanh-DNN with widths 784-400-200-10 is shown in Fig. 1(a) and 1(b). For CIFAR10 dataset, results are shown in Fig. 1(c) and 1(d) of a ReLU-CNN, which consists of one convolution layer of $3 \times 3 \times 6 4$ , a max pooling of $2 \times 2$ , one convolution layer of $3 \times 3 \times 1 2 8$ , a max pooling of $2 \times 2$ , followed by a fully-connected DNN with widths 800-400-400-400-10. For both cases, the output layer of the network is equipped with a softmax. The network output is a 10-d vector. The DNNs are trained with cross entropy loss by Adam optimizer (Kingma & Ba, 2014). (a, b) are for MNIST with a tanh-DNN. The learning rate is 0.001 with batch size 10000. After training, the training accuracy is 0.951 and test accuracy is 0.963. The amplitude of the Fourier coefficient with respect to the fourth output component at each frequency is shown in (a), in which the red dots are computed using the training data. Selected frequencies are marked by black squares. (b) $\Delta _ { F } ( k )$ at different training epochs for the selected frequencies. (c, d)
+
+are for CIFAR10 dataset. We use a ReLU network of a CNN followed by a fully-connected DNN. The learning rate is 0.003 with batch size 512. (c) and (d) are the results with respect to the ninth output component. After training, the training accuracy is 0.98 and test accuracy is 0.72.
+
+In Fig. 2, for MNIST, we use a fully-connected tanh-DNN with widths 784-400-200-10 and MSE loss; for CIFAR10, we use cross-entropy loss and a ReLU-CNN, which consists of one convolution layer of $3 \times 3 \times 3 2$ , a max pooling of $2 \times 2$ , one convolution layer of $3 \times 3 \times 6 4$ , a max pooling of $2 \times 2$ , followed by a fully-connected DNN with widths 400-10 and the output layer of the network is equipped with a softmax. The learning rate for MNIST and CIFAR10 is 0.015 and 0.003, respectively. The networks are trained by Adam optimizer (Kingma & Ba, 2014) with batch size 10000. For VGG16, the learning rate is $\mathrm { { \dot { 1 } 0 ^ { - 5 } } }$ . The network is trained by Adam optimizer (Kingma & Ba, 2014) with batch size 500.
+
+In Fig. 3, the samples are evenly spaced in [0, 1] with sample size 1001. We use a DNN with widths 1-4000-500-400-1 and full batch training by Adam optimizer (Kingma & Ba, 2014). The learning rate is 0.0005. $\beta$ is 10. The parameters of the DNN are initialized following a Gaussian distribution with mean 0 and standard deviation 0.02.
+
+In Fig. 4, the settings of (a) and (b) are the same as the ones in Fig. 1. For (c), we use a tanh-DNN with widths 10-500-100-1, learning rate 0.0005 under full batch-size training by Adam optimizer (Kingma & Ba, 2014). The parameters of the DNN are initialized by a Gaussian distribution with mean 0 and standard deviation 0.05.
+
+# D CENTRAL DIFFERENCE SCHEME AND JACOBI METHOD
+
+Consider a one-dimensional (1-d) Poisson’s equation:
+
+$$
+\begin{array} { c } { { - \Delta u ( x ) = g ( x ) , \quad x \in \Omega = ( - 1 , 1 ) } } \\ { { } } \\ { { u ( x ) = 0 , \quad x = - 1 , 1 . } } \end{array}
+$$
+
+$[ - 1 , 1 ]$ is uniformly discretized into $n + 1$ points with grid size $h = 2 / n$ . The Poisson’s equation in Eq. (9) can be solved by the central difference scheme,
+
+$$
+- \Delta u _ { i } = - \frac { u _ { i + 1 } - 2 u _ { i } + u _ { i - 1 } } { ( \delta x ) ^ { 2 } } = g ( x _ { i } ) , \quad i = 1 , 2 , \cdots , n ,
+$$
+
+resulting a linear system
+
+$$
+\mathbf { } A \mathbf { } u = g ,
+$$
+
+where
+
+$$
+\begin{array} { r } { A = \left( \begin{array} { c c c c c c } { 2 } & { - 1 } & { 0 } & { 0 } & { \cdots } & { 0 } \\ { - 1 } & { 2 } & { - 1 } & { 0 } & { \cdots } & { 0 } \\ { 0 } & { - 1 } & { 2 } & { - 1 } & { \cdots } & { 0 } \\ { \vdots } & { \vdots } & { \cdots } & & & { \vdots } \\ { 0 } & { 0 } & { \cdots } & { 0 } & { - 1 } & { 2 } \end{array} \right) _ { ( n - 1 ) \times ( n - 1 ) } , } \end{array}
+$$
+
+$$
+\pmb { u } = \left( \begin{array} { c } { u _ { 1 } } \\ { u _ { 2 } } \\ { \vdots } \\ { u _ { n - 2 } } \\ { u _ { n - 1 } } \end{array} \right) , \quad \pmb { g } = ( \delta x ) ^ { 2 } \left( \begin{array} { c } { g _ { 1 } } \\ { g _ { 2 } } \\ { \vdots } \\ { g _ { n - 2 } } \\ { g _ { n - 1 } } \end{array} \right) , \quad x _ { i } = 2 \frac { i } { n } .
+$$
+
+A class of methods to solve this linear system is iterative schemes, for example, the Jacobi method. Let $\pmb { A } = \pmb { D } - \pmb { L } - \pmb { U }$ , where $_ { D }$ is the diagonal of $\pmb { A }$ , and $\pmb { L }$ and $U$ are the strictly lower and upper triangular parts of $^ { - A }$ , respectively. Then, we obtain
+
+$$
+\pmb { u } = \pmb { D } ^ { - 1 } ( \pmb { L } + \pmb { U } ) \pmb { u } + \pmb { D } ^ { - 1 } \pmb { g } .
+$$
+
+At step $t \in \mathbb { N }$ , the Jacobi iteration reads as
+
+$$
+\pmb { u } ^ { t + 1 } = \pmb { D } ^ { - 1 } ( \pmb { L } + \pmb { U } ) \pmb { u } ^ { t } + \pmb { D } ^ { - 1 } \pmb { g } .
+$$
+
+We perform the standard error analysis of the above iteration process. Denote $\pmb { u } ^ { * }$ as the true value obtained by directly performing inverse of $\pmb { A }$ in Eq. (11). The error at step $t + 1$ is $\boldsymbol { e } ^ { t + 1 } = \boldsymbol { u } ^ { t + 1 } - \boldsymbol { u } ^ { * }$ . Then, $e ^ { t + \tilde { 1 } } = R _ { J } \dot { e } ^ { t }$ , where $\begin{array} { r } { \dot { \pmb { R _ { J } } } = \pmb { D } ^ { - 1 } ( \pmb { L } + \pmb { U } ) } \end{array}$ . The converging speed of $e ^ { t }$ is determined by the eigenvalues of $R _ { J }$ , that is,
+
+$$
+\lambda _ { k } = \lambda _ { k } ( { \pmb R } _ { J } ) = \cos \frac { k \pi } { n } , \quad k = 1 , 2 , \cdots , n - 1 ,
+$$
+
+and the corresponding eigenvector ${ \pmb v } _ { k }$ ’s entry is
+
+$$
+v _ { k , i } = \sin { \frac { i k \pi } { n } } , i = 1 , 2 , \cdot \cdot \ , n - 1 .
+$$
+
+So we can write
+
+$$
+e ^ { t } = \sum _ { k = 1 } ^ { n - 1 } \alpha _ { k } ^ { t } { v } _ { k } ,
+$$
+
+where $\alpha _ { k } ^ { t }$ can be understood as the magnitude of $e ^ { t }$ in the direction of ${ \boldsymbol { v } } _ { k }$ . Then,
+
+$$
+e ^ { t + 1 } = \sum _ { k = 1 } ^ { n - 1 } \alpha _ { k } ^ { t } R _ { J } { \pmb v } _ { k } = \sum _ { k = 1 } ^ { n - 1 } \alpha _ { k } ^ { t } \lambda _ { k } { \pmb v } _ { k } .
+$$
+
+$$
+\alpha _ { k } ^ { t + 1 } = \lambda _ { k } \alpha _ { k } ^ { t } .
+$$
+
+Therefore, the converging rate of $e ^ { t }$ in the direction of ${ \pmb v } _ { k }$ is controlled by $\lambda _ { k }$ . Since
+
+$$
+\cos { \frac { k \pi } { n } } = - \cos { \frac { ( n - k ) \pi } { n } } ,
+$$
+
+the frequencies $k$ and $( n - k )$ are closely related and converge with the same rate. Consider the frequency $k < n / 2$ , $\lambda _ { k }$ is larger for lower frequency. Therefore, lower frequency converges slower in the Jacobi method.
+
+# E PROOF OF THEOREMS
+
+The activation function we consider is $\sigma ( x ) = \operatorname { t a n h } ( x )$ .
+
+$$
+\sigma ( x ) = \operatorname { t a n h } ( x ) = { \frac { \mathrm { e } ^ { x } - \mathrm { e } ^ { - x } } { \mathrm { e } ^ { x } + \mathrm { e } ^ { - x } } } , \quad x \in \mathbb { R } .
+$$
+
+For a DNN of one hidden layer with $m$ nodes, 1-d input $x$ and 1-d output:
+
+$$
+h ( x ) = \sum _ { j = 1 } ^ { m } a _ { j } \sigma ( w _ { j } x + b _ { j } ) , \quad a _ { j } , w _ { j } , b _ { j } \in \mathbb { R } ,
+$$
+
+where $w _ { j } , a _ { j }$ , and $b _ { j }$ are called parameters, in particular, $w _ { j }$ and $a _ { j }$ are called weights, and $b _ { j }$ is also known as a bias. In the sequel, we will also use the notation $\boldsymbol { \theta } \doteq \{ \boldsymbol { \theta } _ { l j } \}$ with $\theta _ { 1 j } = a _ { j }$ , $\theta _ { 2 j } = w _ { j }$ , and $\theta _ { l j } = b _ { j }$ , $j = 1 , \cdots , m$ . Note that $\begin{array} { r } { \hat { \sigma } ( k ) = - \frac { \mathrm { i } \pi } { \sinh ( \pi k / 2 ) } } \end{array}$ where the Fourier transformation and its inverse transformation are defined as follows:
+
+$$
+\hat { f } ( k ) = \int _ { - \infty } ^ { + \infty } f ( x ) \mathrm { e } ^ { - \mathrm { i } k x } \mathrm { d } x , \quad f ( x ) = \frac { 1 } { 2 \pi } \int _ { - \infty } ^ { + \infty } \hat { f } ( k ) \mathrm { e } ^ { \mathrm { i } k x } \mathrm { d } k .
+$$
+
+The Fourier transform of $\sigma ( w _ { j } x + b _ { j } )$ with $w _ { j } , b _ { j } \in \mathbb { R } , j = 1 , \cdot \cdot \cdot , m$ reads as
+
+$$
+\widehat { \sigma ( w _ { j } \cdot + b _ { j } ) } ( k ) = \frac { 2 \pi \mathrm { i } } { | w _ { j } | } \exp \Big ( \frac { \mathrm { i } b _ { j } k } { w _ { j } } \Big ) \frac { 1 } { \exp ( - \frac { \pi k } { 2 w _ { j } } ) - \exp ( \frac { \pi k } { 2 w _ { j } } ) } .
+$$
+
+Thus
+
+$$
+\hat { h } ( k ) = \sum _ { j = 1 } ^ { m } \frac { 2 \pi a _ { j } \mathrm { i } } { | w _ { j } | } \exp \Big ( \frac { \mathrm { i } b _ { j } k } { w _ { j } } \Big ) \frac { 1 } { \exp \big ( - \frac { \pi k } { 2 w _ { j } } \big ) - \exp \big ( \frac { \pi k } { 2 w _ { j } } \big ) } .
+$$
+
+We define the amplitude deviation between DNN output and the target function $f ( x )$ at frequency $k$ as
+
+$$
+D ( k ) \triangleq { \hat { h } } ( k ) - { \hat { f } } ( k ) .
+$$
+
+Write $D ( k )$ as $D ( k ) = A ( k ) \mathrm { e } ^ { \mathrm { i } \phi ( k ) }$ , where $A ( k ) \in [ 0 , + \infty )$ and $\phi ( k ) \in \mathbb { R }$ are the amplitude and phase of $D ( k )$ , respectively. The loss at frequency $k$ is $\begin{array} { r } { L ( k ) = \frac { 1 } { 2 } \left| D ( k ) \right| ^ { 2 } } \end{array}$ , where $| \cdot |$ denotes the norm of a complex number. The total loss function is defined as: $\begin{array} { r } { L = \int _ { - \infty } ^ { + \infty } L ( k ) \mathrm { d } k } \end{array}$ . Note that according to Parseval’s theorem, this loss function in the Fourier domain is equal to the commonly used loss of mean squared error, that is, $\begin{array} { r } { L = \int _ { - \infty } ^ { + \infty } \frac { 1 } { 2 } ( h ( x ) - f ( x ) ) ^ { 2 } \mathrm { d } x } \end{array}$ . For readers’ reference, we list the partial derivatives of $L ( k )$ with respect to parameters
+
+$$
+\begin{array} { r l } & { \frac { \partial L ( k ) } { \partial a _ { j } } = \frac { 2 \pi } { w _ { j } } \sin \big ( \frac { b _ { j } k } { w _ { j } } - \phi ( k ) \big ) E _ { 0 } , } \\ & { \frac { \partial L ( k ) } { \partial w _ { j } } = \left[ \sin \big ( \frac { b _ { j } k } { w _ { j } } - \phi ( k ) \big ) \left( \frac { \pi ^ { 2 } a _ { j } k } { w _ { j } ^ { 3 } } E _ { 1 } - \frac { 2 \pi a _ { j } } { w _ { j } ^ { 2 } } \right) \right. } \\ & { \left. \phantom { \frac { \partial L ( k ) } { \partial a _ { j } } = } - \frac { 2 \pi a _ { j } b _ { j } k } { w _ { j } ^ { 3 } } \cos \big ( \frac { b _ { j } k } { w _ { j } } - \phi ( k ) \big ) \right] E _ { 0 } , } \\ & { \frac { \partial L ( k ) } { \partial b _ { j } } = \frac { 2 \pi a _ { j } b _ { j } k } { w _ { j } ^ { 2 } } \cos \big ( \frac { b _ { j } k } { w _ { j } } - \phi ( k ) \big ) E _ { 0 } , } \end{array}
+$$
+
+where
+
+$$
+\begin{array} { r l } & { E _ { 0 } = \frac { \mathrm { s g n } ( w _ { j } ) A ( k ) } { \mathrm { e x p } ( \frac { \pi k } { 2 w _ { j } } ) - \mathrm { e x p } ( - \frac { \pi k } { 2 w _ { j } } ) } , } \\ & { E _ { 1 } = \frac { \mathrm { e x p } ( \frac { \pi k } { 2 w _ { j } } ) + \mathrm { e x p } ( - \frac { \pi k } { 2 w _ { j } } ) } { \mathrm { e x p } ( \frac { \pi k } { 2 w _ { j } } ) - \mathrm { e x p } ( - \frac { \pi k } { 2 w _ { j } } ) } . } \end{array}
+$$
+
+The descent increment at any direction, say, with respect to parameter $\theta _ { l j }$ , is
+
+$$
+\frac { \partial L } { \partial \theta _ { l j } } = \int _ { - \infty } ^ { + \infty } \frac { \partial L ( k ) } { \partial \theta _ { l j } } \mathrm { d } k .
+$$
+
+The absolute contribution from frequency $k$ to this total amount at $\theta _ { l j }$ is
+
+$$
+\left. \frac { \partial L ( k ) } { \partial \theta _ { l j } } \right. \approx A ( k ) \exp \left( - | \pi k / 2 w _ { j } | \right) F _ { l j } ( \theta _ { j } , k ) ,
+$$
+
+where $\theta _ { j } \triangleq \{ w _ { j } , b _ { j } , a _ { j } \}$ , $\theta _ { l j } \in \theta _ { j }$ , $F _ { l j } ( \theta _ { j } , k )$ is a function with respect to $\theta _ { j }$ and $k$ , which can be found in one of Eqs. (24, 25, 26).
+
+When the component at frequency $k$ where $\hat { h } ( k )$ is not close enough to $\hat { f } ( k ) , \mathrm { e x p } \left( - | \pi k / 2 w _ { j } | \right)$ would dominate $G _ { l j } ( \theta _ { j } , k )$ for a small $w _ { j }$ . Through the above framework of analysis, we have the following theorem. Define
+
+$$
+W = ( w _ { 1 } , w _ { 2 } , \cdot \cdot \cdot , w _ { m } ) ^ { T } \in \mathbb { R } ^ { m } .
+$$
+
+Theorem. Consider a one hidden layer DNN with activation function $\sigma ( x ) = \operatorname { t a n h } x$ . For any frequencies $k _ { 1 }$ and $k _ { 2 }$ such that $| \hat { f } ( k _ { 1 } ) | > 0 $ , $| \hat { f } ( k _ { 2 } ) | > 0$ , and $| k _ { 2 } | > | k _ { 1 } | > 0$ , there exist positive constants c and $C$ such that for sufficiently small $\delta$ , we have
+
+$$
+\frac { \mu \left( \left\{ W : \left| \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \right| > \left| \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } \right| \quad f o r a l l \quad l , j \right\} \cap B _ { \delta } \right) } { \mu ( B _ { \delta } ) }
+$$
+
+where $B _ { \delta } \subset \mathbb { R } ^ { m }$ is a ball with radius $\delta$ centered at the origin and $\mu ( \cdot )$ is the Lebesgue measure.
+
+We remark that $c$ and $C$ depend on $k _ { 1 }$ , $k _ { 2 }$ $, | { \hat { f } } ( k _ { 1 } ) | , | { \hat { f } } ( k _ { 2 } ) | , \operatorname { s u p } | a _ { i } | , \operatorname { s u p } | b _ { i } | ,$ and $m$ .
+
+Proof. To prove the statement, it is sufficient to show that $\mu ( S _ { l j , \delta } ) / \mu ( B _ { \delta } ) \le C \exp ( - c / \delta )$ for each $l , j$ , where
+
+$$
+S _ { l j , \delta } : = \left\{ W \in B _ { \delta } : \left| \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \right| \leq \left| \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } \right| \right\} .
+$$
+
+We prove this for $S _ { 1 j , \delta }$ , that is, $\theta _ { l j } = a _ { j }$ . The proofs for $\theta _ { l j } = w _ { j }$ and $b _ { j }$ are similar. Without loss of generality, we assume that $k _ { 1 } , k _ { 2 } > 0$ , $b _ { j } > 0$ , and $w _ { j } \neq 0$ , $j = 1 , \cdots , m$ . According to Eq. (24), the inequality $\begin{array} { r } { | \frac { \partial L ( k _ { 1 } ) } { \partial a _ { j } } | \leq | \frac { \partial L ( k _ { 2 } ) } { \partial a _ { j } } | } \end{array}$ is equivalent to
+
+$$
+\frac { A ( k _ { 2 } ) } { A ( k _ { 1 } ) } \lvert \frac { \exp ( \frac { \pi k _ { 1 } } { 2 w _ { j } } ) - \exp ( - \frac { \pi k _ { 1 } } { 2 w _ { j } } ) } { \exp ( \frac { \pi k _ { 2 } } { 2 w _ { j } } ) - \exp ( - \frac { \pi k _ { 2 } } { 2 w _ { j } } ) } \Biggr \rvert \cdot \left. \sin \left( \frac { b _ { j } k _ { 2 } } { w _ { j } } - \phi ( k _ { 2 } ) \right) \right. \geq \left| \sin \left( \frac { b _ { j } k _ { 1 } } { w _ { j } } - \phi ( k _ { 1 } ) \right) \right.
+$$
+
+Note that $\begin{array} { r } { | \hat { h } ( k ) | \le C \sum _ { j = 1 } ^ { m } \frac { | a _ { j } | } { | w _ { j } | } \exp \bigl ( - \frac { \pi k } { 2 | w _ { j } | } \bigr ) } \end{array}$ for $k > 0$ . Thus
+
+$$
+\operatorname * { l i m } _ { W \to 0 } \hat { h } ( k ) = 0 \quad \mathrm { a n d } \quad \operatorname * { l i m } _ { W \to 0 } D ( k ) = - \hat { f } ( k ) .
+$$
+
+Therefore,
+
+$$
+\operatorname* { l i m } _ { W \to 0 } A ( k ) = | \hat { f } ( k ) | \quad \mathrm { a n d } \quad \operatorname* { l i m } _ { W \to 0 } \phi ( k ) = \pi + \arg ( \hat { f } ( k ) ) .
+$$
+
+For $W \in B _ { \delta }$ with sufficiently small $\delta$ , $A ( k _ { 1 } ) > { \textstyle { \frac { 1 } { 2 } } } | { \hat { f } } ( k _ { 1 } ) | > 0$ and $A ( k _ { 2 } ) < 2 | \hat { f } ( k _ { 2 } ) |$ . Also note that $\begin{array} { r } { | \sin ( \frac { b _ { j } k _ { 2 } } { w _ { j } } - \phi ( k _ { 2 } ) ) | \leq 1 } \end{array}$ and that for sufficiently small $\delta$ ,
+
+$$
+\left| \frac { \exp ( \frac { \pi k _ { 1 } } { 2 w _ { j } } ) - \exp ( - \frac { \pi k _ { 1 } } { 2 w _ { j } } ) } { \exp ( \frac { \pi k _ { 2 } } { 2 w _ { j } } ) - \exp ( - \frac { \pi k _ { 2 } } { 2 w _ { j } } ) } \right| \leq 2 \exp \Big ( \frac { - \pi ( k _ { 2 } - k _ { 1 } ) } { 2 | w _ { j } | } \Big ) .
+$$
+
+Thus, inequality (32) implies that
+
+$$
+\Big | \sin \Big ( \frac { b _ { j } k _ { 1 } } { w _ { j } } - \phi ( k _ { 1 } ) \Big ) \Big | \le \frac { 8 | \hat { f } ( k _ { 2 } ) | } { | \hat { f } ( k _ { 1 } ) | } \exp \Big ( - \frac { \pi ( k _ { 2 } - k _ { 1 } ) } { 2 | w _ { j } | } \Big ) .
+$$
+
+Noticing that $\begin{array} { r } { \frac { 2 } { \pi } | x | \leq | \sin x | ( | x | \leq \frac { \pi } { 2 } ) } \end{array}$ and Eq. (34), we have for $W \in S _ { l j , \delta }$ , for some $q \in \mathbb { Z }$ ,
+
+$$
+\left| \frac { b _ { i } k _ { 1 } } { w _ { i } } - \mathrm { a r g } ( \hat { f } ( k _ { 1 } ) ) - q \pi \right| \leq \frac { 8 \pi | \hat { f } ( k _ { 2 } ) | } { | \hat { f } ( k _ { 1 } ) | } \exp \Big ( - \frac { \pi ( k _ { 2 } - k _ { 1 } ) } { 2 \delta } \Big )
+$$
+
+that is,
+
+$$
+- c _ { 1 } \exp ( - c _ { 2 } / \delta ) + q \pi + \arg ( \hat { f } ( k _ { 1 } ) ) \leq \frac { b _ { i } k _ { 1 } } { w _ { i } } \leq c _ { 1 } \exp ( - c _ { 2 } / \delta ) + q \pi + \arg ( \hat { f } ( k _ { 1 } ) ) ,
+$$
+
+where $\begin{array} { r } { c _ { 1 } = \frac { 8 \pi | \hat { f } ( k _ { 2 } ) | } { | \hat { f } ( k _ { 1 } ) | } } \end{array}$ and $c _ { 2 } = \pi ( k _ { 2 } - k _ { 1 } )$ . Define $I : = I ^ { + } \cup I ^ { - }$ where
+
+$$
+I ^ { + } : = \{ w _ { j } > 0 : W \in S _ { 1 j , \delta } \} , \quad I ^ { - } : = \{ w _ { j } < 0 : W \in S _ { 1 j , \delta } \} .
+$$
+
+For $w _ { j } > 0$ , we have for some $q \in \mathbb { Z }$ ,
+
+$$
+0 < \frac { b _ { j } k _ { 1 } } { c _ { 1 } \exp ( - c _ { 2 } / \delta ) + q \pi + \arg ( \hat { f } ( k _ { 1 } ) ) } \leq w _ { j } \leq \frac { b _ { j } k _ { 1 } } { - c _ { 1 } \exp ( - c _ { 2 } / \delta ) + q \pi + \arg ( \hat { f } ( k _ { 1 } ) ) } .
+$$
+
+Since $W \in B _ { \delta }$ and $c _ { 1 } \exp ( - c _ { 2 } / \delta ) + \arg ( \hat { f } ( k _ { 1 } ) ) \leq 2 \pi$ , we have $\begin{array} { r } { \frac { b _ { j } k _ { 1 } } { 2 \pi + q \pi } \leq w _ { j } \leq \delta } \end{array}$ . Then Eq. (40) only holds for some large $q$ , more precisely, $\begin{array} { r } { q \ge q _ { 0 } : = \frac { b _ { j } k } { \pi \delta } - 2 } \end{array}$ bjkπδ − 2. Thus we obtain the estimate for the (one-dimensional) Lebesgue measure of $I ^ { + }$
+
+$$
+\begin{array} { r l } & { \mu ( I ^ { + } ) \leq \displaystyle \sum _ { q = q _ { 0 } } ^ { \infty } \left| \frac { b _ { j } k _ { 1 } } { - c _ { 1 } \exp ( - c _ { 2 } / \delta ) + q \pi + \arg ( \hat { f } ( k _ { 1 } ) ) } - \frac { b _ { j } k _ { 1 } } { c _ { 1 } \exp ( - c _ { 2 } / \delta ) + q \pi + \arg ( \hat { f } ( k _ { 1 } ) ) } \right| } \\ & { \quad \leq 2 | b _ { j } | k _ { 1 } c _ { 1 } \exp ( - c _ { 2 } / \delta ) \cdot \displaystyle \sum _ { q = q _ { 0 } } ^ { \infty } \frac { 1 } { ( q \pi + \arg ( \hat { f } ( k _ { 1 } ) ) ) ^ { 2 } - ( c _ { 1 } \exp ( - c _ { 2 } / \delta ) ) ^ { 2 } } } \\ & { \quad \leq C \exp ( - c / \delta ) . } \end{array}
+$$
+
+The similar estimate holds for $\mu ( I ^ { - } )$ , and hence $\mu ( \underline { { I } } ) \leq C \exp ( - c / \delta )$ . For $W \in B _ { \delta }$ , the $( m - 1 )$ dimensional vector $( w _ { 1 } , \cdot \cdot \cdot , w _ { j - 1 } , w _ { j + 1 } , \cdot \cdot \cdot , w _ { m } ) ^ { T }$ is in a ball with radius $\delta$ in $\mathbb { R } ^ { m - 1 }$ . Therefore, we final arrive at the desired estimate
+
+$$
+\frac { \mu ( S _ { 1 j , \delta } ) } { \mu ( B _ { \delta } ) } \leq \frac { \mu ( I ) \omega _ { m - 1 } \delta ^ { m - 1 } } { \omega _ { m } \delta ^ { m } } \leq C \exp ( - c / \delta ) ,
+$$
+
+where $\omega _ { m }$ is the volume of a unit ball in $\mathbb { R } ^ { m }$ .
+
+Theorem. Considering a DNN of one hidden layer with activation function $\sigma ( x ) = \operatorname { t a n h } ( x )$ . Suppose the target function has only two non-zero frequencies $k _ { 1 }$ and $k _ { 2 }$ , that is, $| { \hat { f } } ( k _ { 1 } ) | > 0$ , $| \hat { f } ( k _ { 2 } ) | > 0 ;$ , and $| \boldsymbol { k } _ { 2 } | > | \boldsymbol { k } _ { 1 } | > 0$ , and $| { \hat { f } } ( k ) | = 0$ for $k \neq k _ { 1 } , k _ { 2 }$ . Consider the loss function of $L = L ( k _ { 1 } ) + L ( k _ { 2 } )$ with gradient descent training. Denote
+
+$$
+\mathcal { S } = \left\{ \frac { \partial L ( k _ { 1 } ) } { \partial t } \leq 0 , \frac { \partial L ( k _ { 1 } ) } { \partial t } \leq \frac { \partial L ( k _ { 2 } ) } { \partial t } \right\} ,
+$$
+
+that is, $L ( k _ { 1 } )$ decreases faster than $L ( k _ { 2 } )$ . There exist positive constants c and $C$ such that for sufficiently small $\delta$ , we have
+
+$$
+\frac { \mu \left( \left\{ W : { \cal S } \mathrm {  ~ \ h o l d s } \right\} \cap { \cal B } _ { \delta } \right) } { \mu ( { \cal B } _ { \delta } ) } \geq 1 - C \exp ( - c / \delta ) ,
+$$
+
+where $B _ { \delta } \subset \mathbb { R } ^ { m }$ is a ball with radius $\delta$ centered at the origin and $\mu ( \cdot )$ is the Lebesgue measure.
+
+Proof. By gradient descent algorithm, we obtain
+
+$$
+\begin{array} { l } { \displaystyle \frac { \partial L ( k _ { 1 } ) } { \partial t } = \sum _ { l , j } \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \frac { \partial \theta _ { l j } } { \partial t } } \\ { \displaystyle = - \sum _ { l , j } \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \frac { \partial ( L ( k _ { 1 } ) + L ( k _ { 2 } ) ) } { \partial \theta _ { l j } } } \\ { \displaystyle = - \sum _ { l , j } \left( \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \right) ^ { 2 } - \sum _ { l , j } \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } , } \end{array}
+$$
+
+$$
+\frac { \partial L ( k _ { 2 } ) } { \partial t } = - \sum _ { l , j } \bigg ( \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } \bigg ) ^ { 2 } - \sum _ { l , j } \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } ,
+$$
+
+and
+
+$$
+\frac { \partial L } { \partial t } = \frac { \partial \left( L ( k _ { 1 } ) + L ( k _ { 2 } ) \right) } { \partial t } = - \sum _ { l , j } \left( \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } + \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } \right) ^ { 2 } \leq 0 .
+$$
+
+To obtain
+
+$$
+0 < \frac { \partial L ( k _ { 1 } ) } { \partial t } - \frac { \partial L ( k _ { 2 } ) } { \partial t } = - \sum _ { l , j } \left[ \left( \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \right) ^ { 2 } - \left( \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } \right) ^ { 2 } \right] ,
+$$
+
+it is sufficient to have
+
+$$
+\left| \frac { \partial L ( k _ { 1 } ) } { \partial \theta _ { l j } } \right| > \left| \frac { \partial L ( k _ { 2 } ) } { \partial \theta _ { l j } } \right| .
+$$
+
+Eqs. (43, 44) also yield to
+
+$$
+\frac { \partial L ( k _ { 1 } ) } { \partial t } < 0 .
+$$
+
+Therefore, Eq. (45) is a sufficient condition for $s$ . Based on the theorem 1, we have proved the theorem 2. □
+
+![](images/8d3a8e2431446d5619f51b1ded986f1e92fff62c137fff4bce0786f9860bea9e.jpg)  
+Figure 6: F-Principle in fitting a natural image. The training data are all pixels whose horizontal indices are odd. We initialize DNN parameters by a Gaussian distribution with mean 0 and standard deviation 0.08 (small initial) or 1 (large initial). (a) True image. (b-g) correspond to the case of the small initial parameters. (f-h) correspond to the case of the large initial parameters. (b) DNN outputs of all pixels at different training epochs. (c, g) DNN outputs (blue) and the true gray-scale (red) of test pixels at the red dashed position in (a). (d) $| { \hat { h } } ( k ) |$ (green) at certain training epoch and $| { \hat { f } } ( k ) |$ (red) at the red dashed position in (a), as a function of frequency index. Selected peaks are marked by black dots. (e, h) $\Delta _ { F } ( k )$ computed by the training data at different epochs for the selected frequencies in (d). (f) DNN outputs of training pixels (left) and all pixels (right) after training. We use a tanh-DNN with widths 2-400-200-100-1. We train the DNN with the full batch and learning rate 0.0002. The DNN is trained by Adam optimizer (Kingma & Ba, 2014) with the MSE loss function.
+
+# F MEMORIZING 2-D IMAGE
+
+We train a DNN to fit a natural image (See Fig. 6(a)), a mapping from coordinate $( x , y )$ to gray scale strength, where the latter is subtracted by its mean and then normalized by the maximal absolute value. First, we initialize DNN parameters by a Gaussian distribution with mean 0 and standard deviation 0.08 (initialization with small parameters). From the snapshots during the training process, we can see that the DNN captures the image from coarse-grained low frequencies to detailed high frequencies (Fig. 6(b)). As an illustration of the F-Principle, we study the Fourier transform of the image with respect to $x$ for a fixed $y$ (red dashed line in Fig. 6(a), denoted as the target function $f ( x )$ in the spatial domain). The DNN can well capture this 1-d slice after training as shown in Fig. 6(c). Fig. 6(d) displays the amplitudes $| { \hat { f } } ( k ) |$ of the first 40 frequency components. Due to the small initial parameters, as an example in Fig. 6(d), when the DNN is fitting low-frequency components, high frequencies stay relatively small. As the relative error shown in Fig. 6(e), the first five frequency peaks converge from low to high in order.
+
+Next, we initialize DNN parameters by a Gaussian distribution with mean 0 and standard deviation 1 (initialization with large parameters). After training, the DNN can well capture the training data, as shown in the left in Fig. 6(f). However, the DNN output at the test pixels are very noisy, as shown in the right in Fig. 6(f). For the pixels at the red dashed lines in Fig. 6(a), as shown in Fig. 6(g), the DNN output fluctuates a lot. Compared with the case of small initial parameters, as shown in Fig. 6(h), the convergence order of the first five frequency peaks do not have a clear order.

parse/train/fIn4wLS2XzU/fIn4wLS2XzU.md

@@ -0,0 +1,266 @@
+# Behavior From the Void: Unsupervised Active Pre-Training
+
+Hao Liu UC Berkeley hao.liu@cs.berkeley.edu
+
+Pieter Abbeel UC Berkeley pabbeel@cs.berkeley.edu
+
+# Abstract
+
+We introduce a new unsupervised pre-training method for reinforcement learning called APT, which stands for Active Pre-Training. APT learns behaviors and representations by actively searching for novel states in reward-free environments. The key novel idea is to explore the environment by maximizing a non-parametric entropy computed in an abstract representation space, which avoids challenging density modeling and consequently allows our approach to scale much better in environments that have high-dimensional observations (e.g., image observations). We empirically evaluate APT by exposing task-specific reward after a long unsupervised pre-training phase. In Atari games, APT achieves human-level performance on 12 games and obtains highly competitive performance compared to canonical fully supervised RL algorithms. On DMControl suite, APT beats all baselines in terms of asymptotic performance and data efficiency and dramatically improves performance on tasks that are extremely difficult to train from scratch.
+
+# 1 Introduction
+
+Reinforcement learning (RL) provides a general framework for solving challenging sequential decision-making problems. When combined with function approximation, it has achieved remarkable success in advancing the frontier of AI technologies. These landmarks include outperforming humans in computer games [40, 51, 64, 5] and solving complex robotic control tasks [3, 1]. Despite these successes, they have to train from scratch to maximize extrinsic reward for every encountered task. This is in sharp contrast with how intelligent creatures quickly adapt to new tasks by leveraging previously acquired behaviors. Unsupervised pre-training, a framework that trains models without expert supervision, has obtained promising results in computer vision [43, 23, 14] and natural language modeling [63, 16, 11]. The learned representation, when fine-tuned on the downstream tasks, can solve them efficiently in a few-shot manner. With the models and datasets growing, performance continues to improve predictably according to scaling laws.
+
+Driven by the significance of massive unlabeled data, we consider an analogy setting of unsupervised pre-training in computer vision where labels are removed during training. The goal of pre-training is to have data efficient adaptation for some downstream task defined in the form of rewards. In RL with unsupervised pre-training, the agent is allowed to train for a long period without access to environment reward, and then only gets exposed to the reward during testing. We first test an array of existing methods for unsupervised pre-training to identity which gaps and challenges exist, we evaluate count-based bonus [10], which encourages the agent to visit novel states. We apply count-based bonus to $\mathrm { D r Q }$ [33] which is current state-of-the-art RL for training from pixels. We also evaluate ImageNet pre-trained representations. The results are shown in Figure 1. We can see that count-based bonus fails to outperform train $\mathrm { D r Q }$ from scratch. We hypothesize that the ineffectiveness stems from density modeling at the pixel level being difficult. ImageNet pre-training does not outperform training from scratch either, which has also been shown in previous research in real world robotics [29]. We believe the reason is that neither of existing methods can provide enough diverse data. Count-based exploration faces the difficult of estimating high dimensional data density while ImageNet dataset is out-of-distribution for DMControl.
+
+To address the issue of obtaining diverse data for RL with unsupervised pre-training, we propose to actively collect novel data by exploring unknown areas in the task-agnostic environment. The underlying intuition is that a general exploration strategy has to visit, with high probability, any state where the agent might be rewarded in a subsequent RL task. Concretely, our approach relies on the entropy maximization principle [27, 53]. Our hope is that by doing so, the learned behavior and representation can be trained on the whole environment while being as task agnostic as possible. Since entropy maximization in high dimensional state space is intractable as an oracle density model is not available, we resort to the particle-based entropy estimator [55, 8]. This estimator is nonparametric and asymptotically unbiased. The key idea is computing the average of the Euclidean distance of each particle to its nearest neighbors for a set of samples. We consider an abstract representation space in order to make the distance meaningful. To learn such a representation space, we adapt the idea of contrastive representation learning [14] to encode image observations to a lower dimensional space. Building upon this insight, we propose Unsupervised Active Pre-Training (APT) since the agent is encouraged to actively explore and leverage the experience to learn behavior.
+
+![](images/3626fc8b63b5733e13d61b9dbb8abac6268cda4e6e208afc6ef0d8852059587f.jpg)  
+Figure 1: Comparison of state-of-the-art pixelbased RL with unsupervised pre-training. APT (ours) and count-based bonus (both based on DrQ [33]) are trained for a long unsupervised period (5M environment steps) without access to environment reward, and then gets exposure to the environment reward during testing. APT significantly outperform training DrQ from scratch, count-based bonus, and ImageNet pre-trained model.
+
+Our approach can be applied to a wide-range of existing RL algorithms. In this paper we consider applying our approach to $_ \mathrm { D r Q }$ [33] which is a state-of-the-art visual RL algorithm. On the Atari 26 games subset, APT significantly improves DrQ’s data-efficiency, achieving $54 \%$ relative improvement. On the full suite of Atari 57 games [40], APT significantly outperforms prior state-of-the-art, achieving a median human-normalized score $3 \times$ higher than the highest score achieved by prior unsupervised RL methods and DQN. On DeepMind control suite, APT beats $_ \mathrm { D r Q }$ and unsupervised RL in terms of asymptotic performance and data efficiency and solving tasks that are extremely difficult to train from scratch. The contributions of our paper can be summarized as: (i) We propose a new approach for unsupervised pre-training for visual RL based a nonparametric particle-based entropy maximization. (ii) We show that our pre-training method significantly improves data efficiency of solving downstream tasks on DMControl and Atari suite.
+
+# 2 Problem Setting
+
+Reinforcement Learning (RL) An agent interacts with its uncertain environment over discrete timesteps and collects reward per action, modeled as a Markov Decision Process (MDP) [48], defined by $\langle S , \mathcal { A } , T , \rho _ { 0 } , r , \gamma \rangle$ where ${ \mathcal { S } } \subseteq \mathbb { R } ^ { n _ { s } }$ is a set of $n _ { \scriptscriptstyle { S } }$ -dimensional states, ${ \mathcal { A } } \subseteq \mathbb { R } ^ { n _ { \mathcal { A } } }$ is a set of $n _ { A }$ dimensional actions, $T : \mathcal { S } \times \mathcal { A } \times \mathcal { S }  [ 0 , 1 ]$ is the state transition probability distribution. $\rho _ { 0 } : { \cal { S } } $ $[ 0 , 1 ]$ is the distribution over initial states, $r : S \times \mathcal { A }  \mathbb { R }$ is the reward function, and $\gamma \in [ 0 , 1 )$ is the discount factor. At environment state $s \in S$ , the agent take actions $a \in { \mathcal { A } }$ , in the (unknown) environment dynamics defined by the transition probability $T ( s ^ { \prime } | s , a )$ , and the reward function yields e action as the d $a _ { t }$ performed in state ounted sum of futur $s _ { t }$ . We define the discounted return rewards collected by the agent. In $\begin{array} { r } { G ( s _ { t } , a _ { t } ) = \sum _ { l = 0 } ^ { \infty } \gamma ^ { \check { l } } r ( s _ { t + l } , a _ { t + l } ) } \end{array}$ value-based reinforcement learning, the agent learns an estimate of the expected discounted return, a.k.a, state-action value function $\begin{array} { r } { \mathsf { \tilde { Q } } ^ { \pi } ( s _ { t } , \mathsf { \tilde { a } } _ { t } ) = \mathbb { E } _ { s _ { t + 1 } , a _ { t + 1 } , \ldots } \left[ \sum _ { l = 0 } ^ { \infty } \gamma ^ { l } r ( \mathsf { \tilde { s } } _ { t + l } , a _ { t + l } ) \right] } \end{array}$ . A common way of deriving a new policy from a state-action value function is to act $\epsilon$ -greedily with respect to the action values (discrete) or to use policy gradient to maximize the value function (continuous).
+
+Unsupervised Pre-Training RL In pretrained RL, the agent is trained in a reward-free MDP $\langle S , S _ { 0 } , A , T , \mathcal { G } \rangle$ for a long period followed by a short testing period with environment rewards $\mathbb { R }$ provided. The goal is to learn a pretrained agent that can quickly adapt to testing tasks defined by rewards to maximize the sum of expected future rewards in a zero-shot or few-shot manner. This is also known as the two phases learning in unsupervised pretraining RL [20]. The current state-of-the-art methods maximize the mutual information $( I )$ between policy-conditioning variable $( w )$ and the behavior induced by the policy in terms of state visitation (s).
+
+$$
+\operatorname* { m a x } I ( s ; w ) = \operatorname* { m a x } H ( w ) - H ( w \vert s ) ,
+$$
+
+where $w$ is sampled from a fixed distribution in practice as in DIAYN [17] and VISR [20]. The objective can then be simplified as max $- H ( w | s )$ . Due to it being intractable to directly maximize this negative conditional entropy, prior work propose to maximize the variational lower bound of the negative conditional entropy instead [7]. The training then amounts to learning a posterior of task variable conditioning on states $q ( w | s )$ .
+
+$$
+- H ( w | s ) \geq \mathbb { E } _ { s , w } \left[ \log q ( w | s ) \right] .
+$$
+
+Despite successful results in learning meaningful behaviors from reward-free interactions [e.g. 41, 18, 26, 17, 20], these methods suffer from insufficient exploration because they contain no explicit exploration.
+
+Another category considers the alternative direction of maximizing the mutual information [12].
+
+$$
+\operatorname* { m a x } I ( s ; w ) = \operatorname* { m a x } H ( s ) - H ( s | w ) .
+$$
+
+This intractable quantity can be similarly lowered bound by a variational approximation [7].
+
+$$
+I ( s ; w ) \geq \mathbb { E } _ { s , w } \left[ q _ { \theta } ( s | w ) \right] - \mathbb { E } _ { s } \left[ \log p ( s ) \right] ,
+$$
+
+where $\mathbb { E } _ { s } \left[ \log p ( s ) \right]$ can then be approximated by a posterior of state given task variables $\mathbb { E } _ { s } \left[ \log p ( s ) \right] \approx \bar { \mathbb { E } _ { s , w } } \left[ \log q ( s | w ) \right]$ . Despite their successes, this category of methods do not explore sufficiently since the agent receives larger rewards for visiting known states than discovering new ones as theoretically and empirically evidenced by Campos et al. [12]. In addition, they have only been shown to work from explicit state-representations and it remains unclear how to modify to learning from pixels.
+
+In the next section, we introduce a new nonparametric unsupervised pre-training method for RL which addresses these issues and outperforms prior state-of-the-arts on challenging visual-domain RL benchmarks.
+
+# 3 Unsupervised Active Pre-Training for RL
+
+We want to incentivize the agent with a reward $r _ { t }$ to maximize entropy in an abstract representation space. Prior work on maximizing entropy relies on estimating density of states which is challenging and non-trivial, instead, we take a two-step approach. First, we learn a mapping $f _ { \theta } : R ^ { n s } \to R ^ { n z }$ that maps state space to an abstract representation space first. Then, we propose a particle-based nonparametric approach to maximize the entropy by deploying state-of-the-art RL algorithms.
+
+We introduce how to maximize entropy via particle-based approximation in Section 3.1, and describe how to learn representation from states in Section 3.2
+
+# 3.1 Particle-Based Entropy Maximization
+
+Our entropy maximization objective is built upon the nonparametric particle-based entropy estimator proposed by Singh et al. [55] and Beirlant [8] and has has been widely studied in statistics [28]. Its key idea is to measure the sparsity of the distribution by considering the distance between each sampled data point and its $k$ nearest neighbors. Concretely, assuming we have number of $n$ data points $\{ z _ { i } \} _ { i = 1 } ^ { n }$ from some unknown distribution, the particle-based approximation can be written as
+
+$$
+H _ { \mathrm { p a r t i c l e } } ( z ) = - \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \log \frac { k } { n \mathrm { v } _ { i } ^ { k } } + b ( k ) \propto \sum _ { i = 1 } ^ { n } \log \mathrm { v } _ { i } ^ { k } ,
+$$
+
+where $b ( k )$ is a bias correction term that only depends on the hyperparameter $k$ , and $\mathrm { v } _ { i } ^ { k }$ is the volume of the hypersphere of radius $\| z _ { i } - z _ { i } ^ { ( k ) } \|$ between $z _ { i }$ and its $k$ -th nearest neighbor $z _ { i } ^ { ( k ) } . \parallel \cdot \parallel$ is the Euclidean distance.
+
+$$
+\mathrm { v } _ { i } ^ { k } = \frac { \| z _ { i } - z _ { i } ^ { ( k ) } \| ^ { n _ { z } } \cdot \pi ^ { n _ { z } / 2 } } { \Gamma \left( n _ { \mathcal { Z } } / 2 + 1 \right) } ,
+$$
+
+![](images/088a2e5327a5fc6614101c8e99926edea51d628f749e6def09ccd3359159faf0.jpg)  
+Figure 2: Diagram of the proposed method APT. On the left shows the objective of APT, which is to maximize the expected reward and minimize the contrastive loss. The contrastive loss learns an abstract representation from observations induced by the policy. We propose a particle-based entropy maximization based reward function such that we can deploy state-of-the-art RL methods to maximize entropy in an abstraction space of the induced by the policy. On the right shows the idea of our particle-based entropy, which measures the distance between each data point and its $\mathbf { k }$ nearest neighbors.
+
+where $\Gamma$ is the gamma function. Intuitively, $\mathrm { v } _ { i } ^ { k }$ reflects the sparsity around each particle and equation (1) is proportional to the average of the volumes around each particle.
+
+By substituting equation (2) into equation (1), we can simplify the particle-based entropy estimation as a sum of the log of the distance between each particle and its $k$ -th nearest neighbor.
+
+$$
+H _ { \mathrm { p a r t i c l e } } ( z ) \propto \sum _ { i = 1 } ^ { n } \log \| z _ { i } - z _ { i } ^ { ( k ) } \| ^ { n z } .
+$$
+
+Rather than using equation (3) as the entropy estimation, we find averaging the distance over all $k$ nearest neighbors leads to a more robust and stable result, yielding our estimation of the entropy.
+
+$$
+H _ { \mathrm { p a r t i c l e } } ( z ) : = \sum _ { i = 1 } ^ { n } \log \left( c + \frac { 1 } { k } \sum _ { z _ { i } ^ { ( j ) } \in \mathrm { N } _ { k } ( z _ { i } ) } \| z _ { i } - z _ { i } ^ { ( j ) } \| ^ { n \ : z } \right) ,
+$$
+
+where $\mathrm { N } _ { k } ( \cdot )$ denotes the $k$ nearest neighbors around a particle, $c$ is a constant for numerical stability (fixed to 1 in all our experiments).
+
+We can view the particle-based entropy in equation (4) as an expected reward with the reward function being $\begin{array} { r } { r ( z _ { i } ) = \log \left( c + \frac { 1 } { k } \sum _ { z _ { i } ^ { ( j ) } \in \mathbb { N } _ { k } ( z _ { i } ) } \| z _ { i } - z _ { i } ^ { ( j ) } \| ^ { n _ { z } } \right) } \end{array}$ for each particle $z _ { i }$ . This makes it possible to deploy RL algorithms to maximize entropy, concretely, for a batch of transitions $\{ ( s , a , s ^ { \prime } ) \}$ sampled from the replay buffer. We consider the representation of each $s ^ { \prime }$ as a particle in the representation space and the reward function for each transition is given by
+
+$$
+r ( s , a , s ^ { \prime } ) = \log \left( c + \frac { 1 } { k } \sum _ { z ^ { ( j ) } \in \mathrm { N } _ { k } ( z = f _ { \theta } ( s ) ) } \| f _ { \theta } ( s ) - z ^ { ( j ) } \| ^ { n _ { z } } \right)
+$$
+
+In order to keep the rewards on a consistent scale, we normalize the intrinsic reward by dividing it by a running estimate of the mean of the intrinsic reward. See Figure 2 for illustration of the formulation.
+
+# 3.2 Learning Contrastive Representations
+
+Our aforementioned entropy maximization is modular of the representation learning method we choose to use, the representation learning part can be swapped out for different methods if necessary. However, for entropy maximization to work, the representation needs to contain a compressed representation of the state. Recent work, CURL [35], ATC [56] and SPR [52], show contrastive learning (with data augmentation) helps learn meaningful representations in RL. We choose contrastive representation learning since it maximally distinguishes an observation $s _ { t _ { 1 } }$ from alternative observations $s _ { t _ { 2 } }$ according to certain distance metric in representation space, we hypothesize is helpful for learning meaningful representations for our nearest neighbors based entropy maximization. Our contrastive learning is based on the contrastive loss from SimCLR [14], chosen for its simplicity. We also use the same set of image augmentations as in DrQ [33] consisting of small random shifts and color jitter. Concretely, we randomly sample a batch of states (images) from the replay buffer $\{ s _ { i } \} _ { i = 1 } ^ { n }$ . For each state $s _ { i }$ , we apply random data augmentation and obtain two randomly augmented views of the same state, denoted as key $s _ { i } ^ { k } = \mathrm { a u g } ( s _ { i } )$ and query $s _ { i } ^ { v } = \mathrm { a u g } ( s _ { i } )$ . The augmented observations are encoded into a small latent space using the encoder $z = f _ { \theta } ( \cdot )$ followed by a deterministic projection $h _ { \phi } ( \cdot )$ where a contrastive loss is applied. The goal of contrastive learning is to ensure that after the encoder and projection, $s _ { i } ^ { k }$ is relatively more close to $s _ { i } ^ { v }$ than any of the data points $\{ s _ { j } ^ { k } , s _ { j } ^ { v } \} _ { j = 1 , j \neq i } ^ { n }$
+
+$$
+\underset { \substack { \theta , \phi } } { \mathrm { n i n } } - \frac { 1 } { 2 n } \sum _ { i = 1 } ^ { n } \left[ \log \frac { \exp ( h _ { \phi } ( f _ { \theta } ( s _ { i } ^ { k } ) ) ^ { T } h _ { \phi } ( f _ { \theta } ( s _ { i } ^ { v } ) ) ) } { \sum _ { i = 1 } ^ { n } \mathbb { I } _ { [ j \neq i ] } ( \exp ( h _ { \phi } ( f _ { \theta } ( s _ { i } ^ { k } ) ) ^ { T } h _ { \phi } ( f _ { \theta } ( s _ { j } ^ { k } ) ) ) + \exp ( h _ { \phi } ( f _ { \theta } ( s _ { i } ^ { k } ) ) ^ { T } h _ { \phi } ( f _ { \theta } ( s _ { j } ^ { v } ) ) ) } \right] .
+$$
+
+Following $\mathrm { D r Q }$ , the representation encoder $f _ { \theta } ( \cdot )$ is implemented by the convolutional residual network followed by a fully-connected layer, a LayerNorm and a Tanh non-linearity. We decrease the output dimension of the fully-connected layer after the convnet from 50 to 15. We find it helps to use spectral normalization [39] to normalize the weights and use ELU [15] as the non-linearity in between convolutional layers.
+
+Table 1 positions our new approach with respect to existing ones. Figure 2 shows the resulting model. Training proceeds as in other algorithms maximizing extrinsic reward: by learning neural encoder $f$ and computing intrinsic reward $r$ and then trying to maximize this intrinsic return by training the policy. Algorithm 1 shows the pseudo-code of APT, we highlight the changes from DrQ to APT in color.
+
+# Algorithm 1: Training APT
+
+<table><tr><td colspan="3">RandomlyInitialize f encoder RandomlyInitialize πand Qnetworks fore:=1, do</td></tr><tr><td colspan="3">fort:=1,Tdo Receive observation st from environment</td></tr><tr><td colspan="3">Take action at ~ π(*|st),receive observation St+1 and T from environment</td></tr><tr><td colspan="3">D ←DU(st,at,t,st) {(si,ai,,s)}-1 ~D</td></tr><tr><td colspan="3">Train neural encoder f on mini batch</td></tr><tr><td colspan="3">for each i=1..N do</td></tr><tr><td colspan="3">a~π(-|s)</td></tr><tr><td colspan="3">Qi=Qe(s,ai)</td></tr><tr><td colspan="3">Compute rAPr with equation (5)</td></tr><tr><td colspan="3">yi ← rAPT +γQi</td></tr><tr><td colspan="3">end</td></tr><tr><td colspan="3">lossQ =∑(Q(si,ai)-yi)²</td></tr><tr><td colspan="3">Gradient descent step on Q and π</td></tr><tr><td colspan="3"></td></tr><tr><td colspan="3">end end</td></tr></table>
+
+Table 1: Methods for pre-training RL in reward-free setting. Exploration: the method can explore efficiently. Visual: the method works well in visual RL. Off-policy: the method is compatible with off-policy RL optimization. ⋆ means only in state-based RL. c(s) is count-based bonus. $\psi ( s , a )$ : successor feature, $\phi ( s )$ : state representation.   
+
+<table><tr><td>Algorithm</td><td>Objective</td><td>Visual</td><td>Exploration</td><td>Off-policy</td><td>Pre-Trained model</td></tr><tr><td>MaxEnt [22]</td><td>maxH(s)</td><td>×</td><td>三</td><td>X</td><td>π(a|s)</td></tr><tr><td>CBB [10]</td><td>maxEs[c(s)]</td><td>×</td><td></td><td></td><td>π(a|s)</td></tr><tr><td>MEPOL [42]</td><td>maxH(s)</td><td></td><td></td><td></td><td>π(a|s)</td></tr><tr><td>VISR [20]</td><td>max-H(z|s)</td><td>x&gt;</td><td></td><td>X</td><td>(s,2），(s)</td></tr><tr><td>DIAYN [17]</td><td>max-H(z|s)+H(a|z,s)</td><td>X</td><td>X</td><td>√</td><td>π(a|s,)</td></tr><tr><td>DADS [54]]</td><td>max H(s) -H(s|z)</td><td>X</td><td>X</td><td>√</td><td>π(a|s,2),q(s&#x27;/s,z)</td></tr><tr><td>EDL [12]</td><td>maxH(s) -H(s|2)</td><td>X</td><td></td><td>√</td><td>π(a|s,2)</td></tr><tr><td>APT</td><td>max H(s)</td><td>√</td><td>√</td><td>√</td><td>π(a|s),Q(s,a)</td></tr></table>
+
+# 4 Related Work
+
+State Space Entropy Maximization. Maximizing entropy of policy has been widely studied in RL, from inverse RL [69] to optimal control [59, 60, 49] and actor-critic [19]. State space entropy maximization has been recently used as an exploration method by estimating density of states and maximizing entropy [22]. In Hazan et al. [22] they present provably efficient exploration algorithms under certain conditions. VAE [32] based entropy estimation has been deployed in lower dimensional observation space [36]. However, due to the difficulty of estimating density in high dimensional space such as Atari games, such parametric exploration methods struggle to work in more challenging visual domains. In contrast, our work turns to particle based entropy maximization in a contrastive representation space. Maximizing particle-based entropy has been shown to improved data efficiency in state-based RL as in MEPOL [42]. However, MEPOL’s entropy estimation depends on importance sampling and the optimization based on on-policy RL algorithms, hindering further applications to challenging visual domains. MEPOL also assumes having access to the semantic information of the state, making it infeasible and not obvious how to modify it to work from pixels. In contrast, our method is compatible with deploying state-of-the-art off-policy RL and representation learning algorithms to maximize entropy. Nonparametric entropy maximization has been studied in goal conditioned RL [66]. Pitis et al. [47] proposes maximizing entropy of achieved goals and demonstrates significantly improved success rates in long horizon goal conditioned tasks. The work by Badia et al. [6] also considers $\mathbf { k }$ -nearest neighbor based count bonus to encourage exploration, yielding improved performance in Atari games. K-nearest neighbor based exploration is shown to improve exploration and data efficiency in model-based RL [57]. Concurrently, it has been shown to be an effective unsupervised pre-training objective for transferring learning in RL [13], their large scale experiments further demonstrate the effectiveness of unsupervised pre-training.
+
+Data Efficient RL. To improve upon the sample efficiency of deep RL methods, various methods have been proposed: Kaiser et al. [30] introduce a model-based agent (SimPLe) and show that it compares favorably to standard RL algorithms when data is limited. Hessel et al. [25], Kielak [31], van Hasselt et al. [61] show combining existing RL algorithms (Rainbow) can boost data efficiency. Data augmentation has also been shown to be effective for improving data efficiency in vision-based RL [34, 33]. Temporal contrastive learning combined with model-based learning has been shown to boost data efficiency [52]. Combining contrastive loss with RL has been shown to improve data efficiency in CPC [24] despite only marginal gains. CURL [35] show substantial data-efficiency gains while follow-up results from Kostrikov et al. [33] suggest that most of the benefits come from its use of image augmentation. Contrastive loss has been shown to learn useful pretrained representations when training on expert demonstration [56], however in our work the agent has to explore the world itself and exploit collect experience.
+
+Unsupervised Pre-Training RL. A number of recent works have sought to improve reinforcement learning via the addition of an unsupervised pretraining stage, in which the agent improves its representations prior to beginning learning on the target task. One common approach has been to allow the agent a period of fully-unsupervised interaction with the environment during which the agent is trained to learn a set of skills associated with different paths through the environment, as in DIAYN [17], Proto-RL [67], MUSIC [68], APS [37], and VISR [20]. Others have proposed to use self-supervised objectives to generate intrinsic rewards encouraging agents to visit new states, e.g., Pathak et al. [46] use the disagreement between an ensemble of latent-space dynamics models. However, our work is trained to maximize the entropy of the states induced by the policy. By visiting any state where the agent might be rewarded in a subsequent RL task, our work performs better or comparably well as other more complex and specialized state-of-the-art methods.
+
+# 5 Results
+
+We test APT in DeepMind Control Suite [DMControl; 58] and the Atari suite [9]. During the the long period of pre-training with environment rewards removed, we use $\mathrm { D r Q }$ to maximize the entropy maximization reward defined in equation (5). The pre-trained value function $Q ( s , a )$ is fine-tuned to maximize task specific reward after being exposing to environment rewards during testing period. For our DeepMind control suite and Atari games experiments, we largely follow $\mathrm { D r Q }$ , except we perform two gradient steps per environment step instead of one. Our ablation studies confirm that these changes are not themselves responsible for our performance. Kornia [50] is used for efficient GPU-based data augmentations. Our model is implemented in Numpy [21] and PyTorch [45].
+
+APT outperforms prior from scratch SOTA RL on DMControl. We evaluate the performance of different methods by computing the average success rate and episodic return at the end of training.
+
+![](images/fe8c8603ef53ddcac9640efceddfb07e4de9b9e5b04fe0e0e9b0cc4599df221b.jpg)  
+Figure 3: Results of different methods in environments from DMControl. All curves are the average of three runs with different seeds, and the shaded areas are standard errors of the mean.
+
+The agent is allowed a long unsupervised pre-training phase (5M steps), followed by a short test phase exposing to downstream reward, during which the pre-trained model is fine-tuned. We follow the evaluation setting of DrQ and test APT on a subset of DMControl suite, which includes training Walker, Cheetah, Hopper for various locomotion tasks. Models are pre-trained on Cheetah, Hopper, and Walker, and subsequently fine-tuned on respective downstream tasks. We additionally design more challenging sparse reward tasks where the robot is required to accomplish tasks guided only by sparse feedback signal. The reason we opted to design new sparse reward tasks is to have more diverse downstream tasks. As far as we know, there is only one Cartpole Swingup Sparse that is a CartPole based sparse reward task. Due to its 2D nature being quite limited, we eventually decided to design distinguishable downstream tasks based on a little bit more complex environment, e.g. Hopper Jump etc. The details of the tasks are included in the supplementary material.
+
+The learning process of RL agents becomes highly inefficient in sparse supervision tasks when relying on standard exploration techniques. This issue can be alleviated by introducing intrinsic motivation, i.e., denser reward signals that can be automatically computed, one approach that works well in high dimensional setting is count-based exploration [38, 44, 38].
+
+The results are presented in Figure 3, APT significantly outperforms SOTA training from scratch (DrQ from scratch) and SOTA exploration method (count-based bonus) on every task. With only a few number of environment interactions, APT quickly adapt to downstream tasks and achieves higher return much more quicker than prior state-of-the-art RL algorithms. Notably, on the sparse reward tasks that are extremely difficult for training from scratch, APT yields significantly higher data efficiency and asymptotic performance.
+
+APT outperforms from scratch SOTA RL in Atari. We test APT on the sample-efficient Atari setting [30, 61] which consists of the 26 easiest games in the Atari suite (as judged by above random performance for their algorithm).
+
+We follow the evaluation setting in VISR, agents are allowed a long unsupervised training phase (250M steps) without access to rewards, followed by a short test phase with rewards. The test phase contains 100K environment steps – equivalent to $4 0 0 \mathrm { k }$ frames, or just under two hours – compared to the typical standard of 500M environment steps, or roughly 39 days of experience. We normalize the episodic return with respect to expert human scores to account for different scales of scores in each game, as done in previous works. The human-normalized scores (HNS) of an agent on a game is calculated as agent score−random scorehuman score−random score and aggregated across games by mean or median.
+
+A full list of scores and aggregate metrics on the Atari 26 subset is presented in Table 2. The results on the full 57 Atari games suite is presented in supplementary material. For consistency with previous works, we report human and random scores from [25]. In the data-limited setting, APT achieves super-human performance on eight games and achieves scores higher than previous state-of-the-arts. In the full suite setting, APT achieves super-human performance on 15 games, compared to a maximum of 12 for any previous methods and achieves scores significantly higher than any previous methods.
+
+Table 2: Performance of different methods on the 26 Atari games considered by [30] after 100K environment steps. The results are recorded at the end of training and averaged over 10 random seeds for APT. APT outperforms prior methods on all aggregate metrics, and exceeds expert human performance on 7 out of 26 games while using a similar amount of experience. Prior work has reported different numbers for some of the baselines, particularly SimPLe and DQN. To be rigorous, we pick the best number for each game across the tables reported in van Hasselt et al. [61] and Kielak [31].   
+
+<table><tr><td>Game</td><td>Random</td><td>Human</td><td>SimPLe</td><td>DER</td><td>CURL</td><td>DrQ</td><td>SPR</td><td>VISR</td><td>APT (ours)</td></tr><tr><td>Alien</td><td>227.8</td><td>7127.7</td><td>616.9</td><td>739.9</td><td>558.2</td><td>771.2</td><td>801.5</td><td>364.4</td><td>2614.8</td></tr><tr><td>Amidar</td><td>5.8</td><td>1719.5</td><td>88.0</td><td>188.6</td><td>142.1</td><td>102.8</td><td>176.3</td><td>186.0</td><td>211.5</td></tr><tr><td>Assault</td><td>222.4</td><td>742.0</td><td>527.2</td><td>431.2</td><td>600.6</td><td>452.4</td><td>571.0</td><td>12091.1</td><td>891.5</td></tr><tr><td>Asterix</td><td>210.0</td><td>8503.3</td><td>1128.3</td><td>470.8</td><td>734.5</td><td>603.5</td><td>977.8</td><td>6216.7</td><td>185.5</td></tr><tr><td>Bank Heist</td><td>14.2</td><td>753.1</td><td>34.2</td><td>51.0</td><td>131.6</td><td>168.9</td><td>380.9</td><td>71.3</td><td>416.7</td></tr><tr><td>BattleZone</td><td>2360.0</td><td>37187.5</td><td>5184.4</td><td>10124.6</td><td>14870.0</td><td>12954.0</td><td>16651.0</td><td>7072.7</td><td>7065.1</td></tr><tr><td>Boxing</td><td>0.1</td><td>12.1</td><td>9.1</td><td>0.2</td><td>1.2</td><td>6.0</td><td>35.8</td><td>13.4</td><td>21.3</td></tr><tr><td>Breakout</td><td>1.7</td><td>30.5</td><td>16.4</td><td>1.9</td><td>4.9</td><td>16.1</td><td>17.1</td><td>17.9</td><td>10.9</td></tr><tr><td>ChopperCommand</td><td>811.0</td><td>7387.8</td><td>1246.9</td><td>861.8</td><td>1058.5</td><td>780.3</td><td>974.8</td><td>800.8</td><td>317.0</td></tr><tr><td>Crazy Climber</td><td>10780.5</td><td>23829.4</td><td>62583.6</td><td>16185.2</td><td>12146.5</td><td>20516.5</td><td>42923.6</td><td>49373.9</td><td>44128.0</td></tr><tr><td>Demon Attack</td><td>107805</td><td>35829.4</td><td>62583.6</td><td>16185.3</td><td>12146.5</td><td>20516.5</td><td>42923.6</td><td>8994.9</td><td>5071.8</td></tr><tr><td>Freeway</td><td>0.0</td><td>29.6</td><td>20.3</td><td>27.9</td><td>26.7</td><td>9.8</td><td>24.4</td><td>-12.1</td><td>29.9</td></tr><tr><td>Frostbite</td><td>65.2</td><td>4334.7</td><td>254.7</td><td>866.8</td><td>1181.3</td><td>331.1</td><td>1821.5</td><td>230.9</td><td>1796.1</td></tr><tr><td>Gopher</td><td>257.6</td><td>2412.5</td><td>771.0</td><td>349.5</td><td>669.3</td><td>636.3</td><td>715.2</td><td>498.6</td><td>2590.4</td></tr><tr><td>Hero</td><td>1027.0</td><td>30826.4</td><td>2656.6</td><td>6857.0</td><td>6279.3</td><td>3736.3</td><td>7019.2</td><td>663.5</td><td>6789.1</td></tr><tr><td>Jamesbond</td><td>29.0</td><td>302.8</td><td>125.3</td><td>301.6</td><td>471.0</td><td>236.0</td><td>365.4</td><td>484.4</td><td>356.1</td></tr><tr><td>Kangaroo</td><td>52.0</td><td>3035.0</td><td>323.1</td><td>779.3</td><td>872.5</td><td>940.6</td><td>3276.4</td><td>1761.9</td><td>412.0</td></tr><tr><td>Krull</td><td>1598.0</td><td>2665.5</td><td>4539.9</td><td>2851.5</td><td>4229.6</td><td>4018.1</td><td>2688.9</td><td>3142.5</td><td>2312.0</td></tr><tr><td>Kung Fu Master</td><td>258.5</td><td>22736.3</td><td>17257.2</td><td>14346.1</td><td>14307.8</td><td>9111.0</td><td>13192.7</td><td>16754.9</td><td>17357.0</td></tr><tr><td>Ms Pacman</td><td>307.3</td><td>6951.6</td><td>1480.0</td><td>1204.1</td><td>1465.5</td><td>960.5</td><td>1313.2</td><td>558.5</td><td>2827.1</td></tr><tr><td>Pong</td><td>-20.7</td><td>14.6</td><td>12.8</td><td>-19.3</td><td>-16.5</td><td>-8.5</td><td>-5.9</td><td>-26.2</td><td>-8.0</td></tr><tr><td>Private Eye</td><td>24.9</td><td>69571.3</td><td>58.3</td><td>97.8</td><td>218.4</td><td>-13.6</td><td>124.0</td><td>98.3</td><td>96.1</td></tr><tr><td>Qbert</td><td>163.9</td><td>13455.0</td><td>1288.8</td><td>1152.9</td><td>1042.4</td><td>854.4</td><td>669.1</td><td>666.3</td><td>17671.2</td></tr><tr><td>Road Runner</td><td>11.5</td><td>7845.0</td><td>5640.6</td><td>9600.0</td><td>5661.0</td><td>8895.1</td><td>14220.5</td><td>6146.7</td><td>4782.1</td></tr><tr><td>Seaquest</td><td>68.4</td><td>42054.7</td><td>683.3</td><td>354.1</td><td>384.5</td><td>301.2</td><td>583.1</td><td>706.6</td><td>2116.7</td></tr><tr><td>Up N Down</td><td>533.4</td><td>11693.2</td><td>3350.3</td><td>2877.4</td><td>2955.2</td><td>3180.8</td><td>28138.5</td><td>10037.6</td><td>8289.4</td></tr><tr><td>Mean HNS</td><td>0.000</td><td>1.000</td><td>44.3</td><td>28.5</td><td>38.1</td><td>35.7</td><td>70.4</td><td>64.31</td><td>69.55</td></tr><tr><td>Median HNS # Superhuman</td><td>0.000 0</td><td>1.000 N/A</td><td>14.4 2</td><td>16.1 2</td><td>17.5 2</td><td>26.8 2</td><td>41.5 7</td><td>12.36 6</td><td>47.50 7</td></tr></table>
+
+Unsupervised pre-training on top of $\mathrm { D r Q }$ leads a significant increase in performance(a $54 \%$ increase in median score, a $73 \%$ increase in mean score, and 5 more games with human-level performance), surpassing DQN which trained on hundreds of millions of sampling steps.
+
+Compared with SPR [52] which is a recent state-of-the-art model-based data-efficient algorithm, APT achieves comparable mean and median scores. The SPR is based on Rainbow which combines more advances than DrQ which is significantly simpler. While the representation of SPR is also learned by contrastive learning, it trains a model-based dynamic to predict its own latent state representations multiple steps into the future. This temporal representation learning, as illustrated in the SPR paper, contributes to its impressive results compared with standard contrastive representation learning. We believe that it is possible to combine temporal contrastive representation learning of SPR with the effective nonparametric entropy maximization of APT, which is an interesting future direction.
+
+APT outperforms prior unsupervised RL. Despite there being many different proposed unsupervised RL methods, their successes are only demonstrated in simple state based environments. Prior works train the agent for a period of fully-unsupervised interaction with the environment, during which the agent is trained to learn a set of skills associated with different paths through the environment, as in DIAYN [17] and VIC [18], or to maximize the diversity of the states it encounters, as in MEPOL [42] and Hazan et al. [22]. Until recently, VISR [20] achieves improved results in Atari games using pixels as input based using a successor feature based approach. In order to compare with prior unsupervised RL methods, we choose DIAYN due to it being based on mutual information maximization and its reported high performance in state-based RL, and MEPOL due to it being based on entropy maximization. We implement them to take pixels as input in Atari games. Our implementation was checked against publicly available code and we made a best effort attempt to tune the algorithms in Atari games. We test two variants of DIAYN and MEPOL, using or not using contrastive representation learning as in APT. In order to ensure a fair comparison, we test a variant of APT without contrastive representation learning.
+
+The aggregated results are presented in Table 3, APT significantly outperforms prior state-based unsupervised RL algorithms DIAYN and MEPOL. Both baselines benefit from contrastive representation learning, but their scores are still significantly lower than APT’s score, confirming that the effectiveness of the off-policy entropy maximization in APT. Compared with the state-of-the-art method in Atari VISR, APT achieves significantly higher median score despite having a lower mean score. From the scores breakdown presented in supplementary file, APT performs significantly better than VISR in hard exploration games, while VISR achieves higher scores in dense reward games. We attribute this to that maximizing state entropy leads to more exploratory behavior while successor features enables quicker adaptation for dense reward feedback. It is possible to combine VISR and APT to have the best of both worlds, which we leave as a future work.
+
+Table 3: Evaluation in Atari games. The amount of RL interaction utilized is 100K. M dn is the median of human-normalized scores, $M$ is the mean and $> H$ is the number of games with human-level performance. CL denotes training representation encoder using contrastive learning and data augmentation. On each subset, we mark as bold the highest score.   
+
+<table><tr><td></td><td colspan="3">26 Game Subset</td><td colspan="3">Full 57 Games</td></tr><tr><td>Algorithm</td><td>Mdn</td><td>M</td><td></td><td>&gt;H Mdn</td><td>M</td><td>&gt;H</td></tr><tr><td>CBB</td><td>1.23</td><td>21.94</td><td>3</td><td></td><td></td><td>1</td></tr><tr><td>MEPOL</td><td>0.34</td><td>17.94</td><td>2</td><td>一</td><td></td><td>1</td></tr><tr><td>DIAYN</td><td>1.34</td><td>25.39</td><td>2</td><td>2.95</td><td>23.90</td><td>6</td></tr><tr><td>CBB w/CL</td><td>1.78</td><td>17.34</td><td>2</td><td>1</td><td>1</td><td>1</td></tr><tr><td>MEPOL W/ CL</td><td>1.05</td><td>21.78</td><td>3</td><td>1</td><td>一</td><td></td></tr><tr><td>DIAYN w/ CL</td><td>1.76</td><td>28.44</td><td>2</td><td>3.28</td><td>25.14</td><td>6</td></tr><tr><td>VISR</td><td>9.50</td><td>128.07</td><td>7</td><td>6.81</td><td>102.31</td><td>11</td></tr><tr><td>APT w/o CL</td><td>21.23</td><td>28.12</td><td>3</td><td>28.65</td><td>41.12</td><td>9</td></tr><tr><td>APT</td><td>47.50</td><td>69.55</td><td>7</td><td>33.41</td><td>47.73</td><td>12</td></tr></table>
+
+Ablation study. We conduct several ablation studies to measure the contribution of each component in our method. We test two variants of APT that use the same number of gradient steps per environment step and use the same activation function as in DrQ. Another variant of APT is based on randomly selected neighbors to compute particle-based entropy.
+
+We also test a variant of APT that use a fixed randomly initialized encoder to study the impact of representation learning. Table 4 shows the performance of each variant of APT. Increasing gradient steps of updating value function from 1 to 2 and using ELU activation function yield higher scores. Using $\mathbf { k }$ -nearest neighbors is crucial to high scores, we believe the reason is randomly selected neighbors do not provide necessary incentive to explore. Using randomly initialized convolutional encoder downgrades performance significantly but still achieve higher score than $\mathrm { D r Q }$ , indicating our particlebased entropy maximization is robust and powerful.
+
+Table 4: Scores on the 26 Atari games under consideration for variants of APT. Scores are averaged over 3 random seeds. All variants listed here use data augmentation.   
+
+<table><tr><td>Variant</td><td>Human-Normalized Score median mean</td></tr><tr><td>APT</td><td>47.50</td></tr><tr><td>APT w/o optim change</td><td>41.50</td></tr><tr><td>APT w/o arch change</td><td>45.71</td></tr><tr><td>APT w/ rand neighbor</td><td>20.80 33.24</td></tr><tr><td>APT w/ fixed encoder</td><td>24.97 41.08</td></tr></table>
+
+Contrastive learning representation has   
+been shown to have the “uniformity on the hypersphere” property [65], this leads to the question that whether maximum entropy exploration in state space is important. To study this question, we have a variant of APT “Pos Reward APT” which receives a simple positive do not die signal but no particle-based entropy reward. We ran the experiments on MsPacman, we reduced the pretraining phase to 5M steps to reduce computation cost. The evaluation metrics are the number of ram states visited using [2] and the downstream zero shot performance on Atari game. APT visits nearly 27 times more unique ram states than “Pos Reward APT”, showing that the entropy intrinsic reward is indispensable for exploration. In downstream task evaluation over 3 random seeds, “Pos Reward APT $@ 0 ^ { , 9 }$ achieves reward 363.7, “APT $@ 0 ^ { , , }$ achieves reward 687.1, showing that the “do not die” signal is insufficient for exploration or learning pretrained behaviors and representations.
+
+We consider a variant of APT that re-initialize the head of pretrained actor-critic. We have run experiments in five different Atari games, as shown in Table 5, pretrained heads
+
+Table 5: Scores on 5 Atari games under consideration for different variants of fine-tuning. Scores are averaged over 3 random seeds.   
+
+<table><tr><td>Mean Reward (3 seeds)</td><td>Alien</td><td>Freeway</td><td>Qbert</td><td>Private Eye</td><td>MsPacman</td></tr><tr><td>APT (pretrained head)</td><td>2614.8</td><td>29.9</td><td>17671.2</td><td>96.1</td><td>2827.1</td></tr><tr><td>APT (random head)</td><td>1755.0</td><td>15.2</td><td>2138.3</td><td>61.3</td><td>1724.9</td></tr></table>
+
+perform better than randomly initialized heads in 4 out of 5 games. The experiments demonstrate that finetuning from a pretrained actor-critic head accelerates learning. However, we believe that which one of the two is better depends on the alignment between downstream reward and intrinsic reward. It would be interesting to study how to better leverage downstream reward to finetune the pretrained model.
+
+# 6 Discussion
+
+Limitation: The fine-tuning strategy employed here (when combined with a value function) works best when the intrinsic and extrinsic rewards being of a similar scale. We believe the discrepancy between intrinsic reward scale and downstream reward scale possibly explain the suboptimal performance of APT in dense reward games. This is an interesting future direction to further improve APT, we hypothesize that reinitializing behaviors part (actor-critic heads) might be useful if the downstream reward scale is very different from pretraining reward scale. One of the principled ways could be adaptive normalization [62], it is an interesting future direction. One challenge of our method is the non-stationarity of the intrinsic reward, being non additive reward poses an interesting challenge for reinforcement learning methods. While our method outperforms training from scratch and prior works, we believe designing better optimization RL methods for maximizing our intrinsic reward can lead to more significant improvement.
+
+Conclusion: A new unsupervised pre-training method for RL is introduced to address reward-free pre-training for visual RL, allowing the same task-agnostic pre-trained model to successfully tackle a broad set of RL tasks. Our major contribution is introducing a practical intrinsic reward derived from particle-based entropy maximization in abstract representation space. Empirical study on DMControl suite and Atari games show our method dramatically improves performance on tasks that are extremely difficult for training from scratch. Our method achieves the results of fully supervised canonical RL algorithms using a small fraction of total samples and outperforms data-efficient supervised RL methods.
+
+For future work, there are a few ways in which our method can be improved. The long pre-training phase in our work is computationally intensive, since the exhaustive search and exploration is of high sample complexity. One way to remedy this is by combining our method with successful model-based RL and search approaches to reduce sample complexity. Furthermore, fine-tuning the whole pretrained model can make it prone to catastrophic forgetting. As such, it is worth studying alternative methods to leverage the pre-trained models such as keeping the pretrained model unchanged and combine it with a randomly initialized model.
+
+# 7 Acknowledgment
+
+This research was supported by DARPA Data-Driven Discovery of Models (D3M) program. We would like to thank Misha Laskin, Olivia Watkins, Qiyang Li, Lerrel Pinto, Kimin Lee and other members at RLL and BAIR for insightful discussion and giving constructive comments. We would also like to thank anonymous reviewers for their helpful feedback for previous versions of our work.
+
+# References
+
+[1] I. Akkaya, M. Andrychowicz, M. Chociej, M. Litwin, B. McGrew, A. Petron, A. Paino, M. Plappert, G. Powell, R. Ribas, et al. Solving rubik’s cube with a robot hand. arXiv preprint arXiv:1910.07113, 2019.   
+[2] A. Anand, E. Racah, S. Ozair, Y. Bengio, M. Côté, and R. D. Hjelm. Unsupervised state representation learning in atari. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 8766–8779, 2019. [3] M. Andrychowicz, D. Crow, A. Ray, J. Schneider, R. Fong, P. Welinder, B. McGrew, J. Tobin, P. Abbeel, and W. Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5048–5058, 2017. [4] J. L. Ba, J. R. Kiros, and G. E. Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. [5] A. P. Badia, B. Piot, S. Kapturowski, P. Sprechmann, A. Vitvitskyi, Z. D. Guo, and C. Blundell. Agent57: Outperforming the atari human benchmark. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 507–517. PMLR, 2020.   
+[6] A. P. Badia, P. Sprechmann, A. Vitvitskyi, D. Guo, B. Piot, S. Kapturowski, O. Tieleman, M. Arjovsky, A. Pritzel, A. Bolt, and C. Blundell. Never give up: Learning directed exploration strategies. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. [7] D. Barber and F. V. Agakov. The im algorithm: A variational approach to information maximization. In Advances in neural information processing systems, 2003. [8] J. Beirlant. Nonparametric entropy estimation: An overview. International Journal of the Mathematical Statistics Sciences, 6:17–39, 1997.   
+[9] M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   
+[10] M. G. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pages 1471–1479, 2016.   
+[11] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   
+[12] V. Campos, A. Trott, C. Xiong, R. Socher, X. Giró-i-Nieto, and J. Torres. Explore, discover and learn: Unsupervised discovery of state-covering skills. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 1317–1327. PMLR, 2020.   
+[13] V. Campos, P. Sprechmann, S. S. Hansen, A. Barreto, C. Blundell, A. Vitvitskyi, S. Kapturowski, and A. P. Badia. Coverage as a principle for discovering transferable behavior in reinforcement learning, 2021.   
+[14] T. Chen, S. Kornblith, M. Norouzi, and G. E. Hinton. A simple framework for contrastive learning of visual representations. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 1597–1607. PMLR, 2020.   
+[15] D. Clevert, T. Unterthiner, and S. Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings, 2016.   
+[16] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota, 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1423.   
+[17] B. Eysenbach, A. Gupta, J. Ibarz, and S. Levine. Diversity is all you need: Learning skills without a reward function. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   
+[18] K. Gregor, D. J. Rezende, and D. Wierstra. Variational intrinsic control. arXiv preprint arXiv:1611.07507, 2016.   
+[19] T. Haarnoja, A. Zhou, P. Abbeel, and S. Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmässan, Stockholm, Sweden, July 10-15, 2018, volume 80 of Proceedings of Machine Learning Research, pages 1856–1865. PMLR, 2018.   
+[20] S. Hansen, W. Dabney, A. Barreto, D. Warde-Farley, T. V. de Wiele, and V. Mnih. Fast task inference with variational intrinsic successor features. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[21] C. R. Harris, K. J. Millman, S. J. van der Walt, R. Gommers, P. Virtanen, D. Cournapeau, E. Wieser, J. Taylor, S. Berg, N. J. Smith, et al. Array programming with numpy. Nature, 585 (7825):357–362, 2020.   
+[22] E. Hazan, S. M. Kakade, K. Singh, and A. V. Soest. Provably efficient maximum entropy exploration. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 2681–2691. PMLR, 2019.   
+[23] K. He, H. Fan, Y. Wu, S. Xie, and R. B. Girshick. Momentum contrast for unsupervised visual representation learning. In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2020, Seattle, WA, USA, June 13-19, 2020, pages 9726–9735. IEEE, 2020. doi: 10.1109/CVPR42600.2020.00975.   
+[24] O. J. Hénaff. Data-efficient image recognition with contrastive predictive coding. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 4182–4192. PMLR, 2020.   
+[25] M. Hessel, J. Modayil, H. van Hasselt, T. Schaul, G. Ostrovski, W. Dabney, D. Horgan, B. Piot, M. G. Azar, and D. Silver. Rainbow: Combining improvements in deep reinforcement learning. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pages 3215–3222. AAAI Press, 2018.   
+[26] R. Houthooft, X. Chen, Y. Duan, J. Schulman, F. D. Turck, and P. Abbeel. VIME: variational information maximizing exploration. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pages 1109–1117, 2016.   
+[27] E. T. Jaynes. Information theory and statistical mechanics. Physical review, 106(4):620, 1957.   
+[28] J. Jiao, W. Gao, and Y. Han. The nearest neighbor information estimator is adaptively near minimax rate-optimal. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal, Canada, pages 3160–3171, 2018.   
+[29] R. Julian, B. Swanson, G. S. Sukhatme, S. Levine, C. Finn, and K. Hausman. Never stop learning: The effectiveness of fine-tuning in robotic reinforcement learning. arXiv e-prints, pages arXiv–2004, 2020.   
+[30] L. Kaiser, M. Babaeizadeh, P. Milos, B. Osinski, R. H. Campbell, K. Czechowski, D. Erhan, C. Finn, P. Kozakowski, S. Levine, A. Mohiuddin, R. Sepassi, G. Tucker, and H. Michalewski. Model based reinforcement learning for atari. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[31] K. Kielak. Do recent advancements in model-based deep reinforcement learning really improve data efficiency? arXiv preprint arXiv:2003.10181, 2020.   
+[32] D. P. Kingma and M. Welling. Auto-encoding variational bayes. In 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, 2014.   
+[33] I. Kostrikov, D. Yarats, and R. Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649, 2020.   
+[34] M. Laskin, K. Lee, A. Stooke, L. Pinto, P. Abbeel, and A. Srinivas. Reinforcement learming with augmented data. arXiv:2004.14990, 2020.   
+[35] M. Laskin, A. Srinivas, and P. Abbeel. CURL: contrastive unsupervised representations for reinforcement learning. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 5639–5650. PMLR, 2020.   
+[36] L. Lee, B. Eysenbach, E. Parisotto, E. Xing, S. Levine, and R. Salakhutdinov. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274, 2019.   
+[37] H. Liu and P. Abbeel. Aps: Active pretraining with successor features. In International Conference on Machine Learning, pages 6736–6747. PMLR, 2021.   
+[38] M. C. Machado, M. G. Bellemare, and M. Bowling. Count-based exploration with the successor representation. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020, pages 5125–5133. AAAI Press, 2020.   
+[39] T. Miyato, T. Kataoka, M. Koyama, and Y. Yoshida. Spectral normalization for generative adversarial networks. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018.   
+[40] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.   
+[41] S. Mohamed and D. J. Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 2125–2133, 2015.   
+[42] M. Mutti, L. Pratissoli, and M. Restelli. A policy gradient method for task-agnostic exploration. arXiv preprint arXiv:2007.04640, 2020.   
+[43] A. v. d. Oord, Y. Li, and O. Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.   
+[44] G. Ostrovski, M. G. Bellemare, A. van den Oord, and R. Munos. Count-based exploration with neural density models. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pages 2721–2730. PMLR, 2017.   
+[45] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Köpf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 8024–8035, 2019.   
+[46] D. Pathak, D. Gandhi, and A. Gupta. Self-supervised exploration via disagreement. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 5062–5071. PMLR, 2019.   
+[47] S. Pitis, H. Chan, S. Zhao, B. Stadie, and J. Ba. Maximum entropy gain exploration for long horizon multi-goal reinforcement learning. In International Conference on Machine Learning, pages 7750–7761. PMLR, 2020.   
+[48] M. L. Puterman. Markov decision processes: discrete stochastic dynamic programming. John Wiley &amp; Sons, 2014.   
+[49] K. Rawlik, M. Toussaint, and S. Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. Proceedings of Robotics: Science and Systems VIII, 2012.   
+[50] E. Riba, D. Mishkin, D. Ponsa, E. Rublee, and G. Bradski. Kornia: an open source differentiable computer vision library for pytorch. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 3674–3683, 2020.   
+[51] J. Schrittwieser, I. Antonoglou, T. Hubert, K. Simonyan, L. Sifre, S. Schmitt, A. Guez, E. Lockhart, D. Hassabis, T. Graepel, et al. Mastering atari, go, chess and shogi by planning with a learned model. arXiv preprint arXiv:1911.08265, 2019.   
+[52] M. Schwarzer, A. Anand, R. Goel, R. D. Hjelm, A. Courville, and P. Bachman. Data-efficient reinforcement learning with self-predictive representations. In International Conference on Learning Representations, 2021.   
+[53] C. E. Shannon. A mathematical theory of communication. The Bell system technical journal, 27(3):379–423, 1948.   
+[54] A. Sharma, S. Gu, S. Levine, V. Kumar, and K. Hausman. Dynamics-aware unsupervised discovery of skills. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[55] H. Singh, N. Misra, V. Hnizdo, A. Fedorowicz, and E. Demchuk. Nearest neighbor estimates of entropy. American journal of mathematical and management sciences, 23(3-4):301–321, 2003.   
+[56] A. Stooke, K. Lee, P. Abbeel, and M. Laskin. Decoupling representation learning from reinforcement learning. arXiv preprint arXiv:2009.08319, 2020.   
+[57] R. Y. Tao, V. François-Lavet, and J. Pineau. Novelty search in representational space for sample efficient exploration. arXiv preprint arXiv:2009.13579, 2020.   
+[58] Y. Tassa, S. Tunyasuvunakool, A. Muldal, Y. Doron, S. Liu, S. Bohez, J. Merel, T. Erez, T. Lillicrap, and N. Heess. dm_control: Software and tasks for continuous control. arXiv preprint arXiv:2006.12983, 2020.   
+[59] E. Todorov. General duality between optimal control and estimation. In 2008 47th IEEE Conference on Decision and Control, pages 4286–4292. IEEE, 2008.   
+[60] M. Toussaint. Robot trajectory optimization using approximate inference. In Proceedings of the 26th Annual International Conference on Machine Learning, ICML 2009, Montreal, Quebec, Canada, June 14-18, 2009, volume 382 of ACM International Conference Proceeding Series, pages 1049–1056. ACM, 2009. doi: 10.1145/1553374.1553508.   
+[61] H. van Hasselt, M. Hessel, and J. Aslanides. When to use parametric models in reinforcement learning? In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 14322–14333, 2019.   
+[62] H. P. van Hasselt, A. Guez, M. Hessel, V. Mnih, and D. Silver. Learning values across many orders of magnitude. Advances in Neural Information Processing Systems, 29:4287–4295, 2016.   
+[63] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5998–6008, 2017.   
+[64] O. Vinyals, I. Babuschkin, W. M. Czarnecki, M. Mathieu, A. Dudzik, J. Chung, D. H. Choi, R. Powell, T. Ewalds, P. Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019.   
+[65] T. Wang and P. Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. In International Conference on Machine Learning, pages 9929–9939. PMLR, 2020.   
+[66] D. Warde-Farley, T. V. de Wiele, T. D. Kulkarni, C. Ionescu, S. Hansen, and V. Mnih. Unsupervised control through non-parametric discriminative rewards. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   
+[67] D. Yarats, R. Fergus, A. Lazaric, and L. Pinto. Reinforcement learning with prototypical representations. arXiv preprint arXiv:2102.11271, 2021.   
+[68] R. Zhao, Y. Gao, P. Abbeel, V. Tresp, and W. Xu. Mutual information state intrinsic control. arXiv preprint arXiv:2103.08107, 2021.   
+[69] B. D. Ziebart, A. L. Maas, J. A. Bagnell, and A. K. Dey. Maximum entropy inverse reinforcement learning. In Aaai, volume 8, pages 1433–1438. Chicago, IL, USA, 2008.

parse/train/fIn4wLS2XzU/fIn4wLS2XzU_content_list.json

@@ -0,0 +1,1142 @@
+[
+    {
+        "type": "text",
+        "text": "Behavior From the Void: Unsupervised Active Pre-Training ",
+        "text_level": 1,
+        "bbox": [
+            220,
+            122,
+            777,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hao Liu UC Berkeley hao.liu@cs.berkeley.edu ",
+        "bbox": [
+            253,
+            226,
+            455,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pieter Abbeel UC Berkeley pabbeel@cs.berkeley.edu ",
+        "bbox": [
+            542,
+            226,
+            743,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            304,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce a new unsupervised pre-training method for reinforcement learning called APT, which stands for Active Pre-Training. APT learns behaviors and representations by actively searching for novel states in reward-free environments. The key novel idea is to explore the environment by maximizing a non-parametric entropy computed in an abstract representation space, which avoids challenging density modeling and consequently allows our approach to scale much better in environments that have high-dimensional observations (e.g., image observations). We empirically evaluate APT by exposing task-specific reward after a long unsupervised pre-training phase. In Atari games, APT achieves human-level performance on 12 games and obtains highly competitive performance compared to canonical fully supervised RL algorithms. On DMControl suite, APT beats all baselines in terms of asymptotic performance and data efficiency and dramatically improves performance on tasks that are extremely difficult to train from scratch. ",
+        "bbox": [
+            232,
+            337,
+            766,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            542,
+            312,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning (RL) provides a general framework for solving challenging sequential decision-making problems. When combined with function approximation, it has achieved remarkable success in advancing the frontier of AI technologies. These landmarks include outperforming humans in computer games [40, 51, 64, 5] and solving complex robotic control tasks [3, 1]. Despite these successes, they have to train from scratch to maximize extrinsic reward for every encountered task. This is in sharp contrast with how intelligent creatures quickly adapt to new tasks by leveraging previously acquired behaviors. Unsupervised pre-training, a framework that trains models without expert supervision, has obtained promising results in computer vision [43, 23, 14] and natural language modeling [63, 16, 11]. The learned representation, when fine-tuned on the downstream tasks, can solve them efficiently in a few-shot manner. With the models and datasets growing, performance continues to improve predictably according to scaling laws. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Driven by the significance of massive unlabeled data, we consider an analogy setting of unsupervised pre-training in computer vision where labels are removed during training. The goal of pre-training is to have data efficient adaptation for some downstream task defined in the form of rewards. In RL with unsupervised pre-training, the agent is allowed to train for a long period without access to environment reward, and then only gets exposed to the reward during testing. We first test an array of existing methods for unsupervised pre-training to identity which gaps and challenges exist, we evaluate count-based bonus [10], which encourages the agent to visit novel states. We apply count-based bonus to $\\mathrm { D r Q }$ [33] which is current state-of-the-art RL for training from pixels. We also evaluate ImageNet pre-trained representations. The results are shown in Figure 1. We can see that count-based bonus fails to outperform train $\\mathrm { D r Q }$ from scratch. We hypothesize that the ineffectiveness stems from density modeling at the pixel level being difficult. ImageNet pre-training does not outperform training from scratch either, which has also been shown in previous research in real world robotics [29]. We believe the reason is that neither of existing methods can provide enough diverse data. Count-based exploration faces the difficult of estimating high dimensional data density while ImageNet dataset is out-of-distribution for DMControl. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address the issue of obtaining diverse data for RL with unsupervised pre-training, we propose to actively collect novel data by exploring unknown areas in the task-agnostic environment. The underlying intuition is that a general exploration strategy has to visit, with high probability, any state where the agent might be rewarded in a subsequent RL task. Concretely, our approach relies on the entropy maximization principle [27, 53]. Our hope is that by doing so, the learned behavior and representation can be trained on the whole environment while being as task agnostic as possible. Since entropy maximization in high dimensional state space is intractable as an oracle density model is not available, we resort to the particle-based entropy estimator [55, 8]. This estimator is nonparametric and asymptotically unbiased. The key idea is computing the average of the Euclidean distance of each particle to its nearest neighbors for a set of samples. We consider an abstract representation space in order to make the distance meaningful. To learn such a representation space, we adapt the idea of contrastive representation learning [14] to encode image observations to a lower dimensional space. Building upon this insight, we propose Unsupervised Active Pre-Training (APT) since the agent is encouraged to actively explore and leverage the experience to learn behavior. ",
+        "bbox": [
+            174,
+            138,
+            517,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/3626fc8b63b5733e13d61b9dbb8abac6268cda4e6e208afc6ef0d8852059587f.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of state-of-the-art pixelbased RL with unsupervised pre-training. APT (ours) and count-based bonus (both based on DrQ [33]) are trained for a long unsupervised period (5M environment steps) without access to environment reward, and then gets exposure to the environment reward during testing. APT significantly outperform training DrQ from scratch, count-based bonus, and ImageNet pre-trained model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            535,
+            141,
+            816,
+            300
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            429,
+            823,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach can be applied to a wide-range of existing RL algorithms. In this paper we consider applying our approach to $_ \\mathrm { D r Q }$ [33] which is a state-of-the-art visual RL algorithm. On the Atari 26 games subset, APT significantly improves DrQ’s data-efficiency, achieving $54 \\%$ relative improvement. On the full suite of Atari 57 games [40], APT significantly outperforms prior state-of-the-art, achieving a median human-normalized score $3 \\times$ higher than the highest score achieved by prior unsupervised RL methods and DQN. On DeepMind control suite, APT beats $_ \\mathrm { D r Q }$ and unsupervised RL in terms of asymptotic performance and data efficiency and solving tasks that are extremely difficult to train from scratch. The contributions of our paper can be summarized as: (i) We propose a new approach for unsupervised pre-training for visual RL based a nonparametric particle-based entropy maximization. (ii) We show that our pre-training method significantly improves data efficiency of solving downstream tasks on DMControl and Atari suite. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            628
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Problem Setting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            341,
+            670
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning (RL) An agent interacts with its uncertain environment over discrete timesteps and collects reward per action, modeled as a Markov Decision Process (MDP) [48], defined by $\\langle S , \\mathcal { A } , T , \\rho _ { 0 } , r , \\gamma \\rangle$ where ${ \\mathcal { S } } \\subseteq \\mathbb { R } ^ { n _ { s } }$ is a set of $n _ { \\scriptscriptstyle { S } }$ -dimensional states, ${ \\mathcal { A } } \\subseteq \\mathbb { R } ^ { n _ { \\mathcal { A } } }$ is a set of $n _ { A }$ dimensional actions, $T : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S }  [ 0 , 1 ]$ is the state transition probability distribution. $\\rho _ { 0 } : { \\cal { S } } $ $[ 0 , 1 ]$ is the distribution over initial states, $r : S \\times \\mathcal { A }  \\mathbb { R }$ is the reward function, and $\\gamma \\in [ 0 , 1 )$ is the discount factor. At environment state $s \\in S$ , the agent take actions $a \\in { \\mathcal { A } }$ , in the (unknown) environment dynamics defined by the transition probability $T ( s ^ { \\prime } | s , a )$ , and the reward function yields e action as the d $a _ { t }$ performed in state ounted sum of futur $s _ { t }$ . We define the discounted return rewards collected by the agent. In $\\begin{array} { r } { G ( s _ { t } , a _ { t } ) = \\sum _ { l = 0 } ^ { \\infty } \\gamma ^ { \\check { l } } r ( s _ { t + l } , a _ { t + l } ) } \\end{array}$ value-based reinforcement learning, the agent learns an estimate of the expected discounted return, a.k.a, state-action value function $\\begin{array} { r } { \\mathsf { \\tilde { Q } } ^ { \\pi } ( s _ { t } , \\mathsf { \\tilde { a } } _ { t } ) = \\mathbb { E } _ { s _ { t + 1 } , a _ { t + 1 } , \\ldots } \\left[ \\sum _ { l = 0 } ^ { \\infty } \\gamma ^ { l } r ( \\mathsf { \\tilde { s } } _ { t + l } , a _ { t + l } ) \\right] } \\end{array}$ . A common way of deriving a new policy from a state-action value function is to act $\\epsilon$ -greedily with respect to the action values (discrete) or to use policy gradient to maximize the value function (continuous). ",
+        "bbox": [
+            173,
+            679,
+            825,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised Pre-Training RL In pretrained RL, the agent is trained in a reward-free MDP $\\langle S , S _ { 0 } , A , T , \\mathcal { G } \\rangle$ for a long period followed by a short testing period with environment rewards $\\mathbb { R }$ provided. The goal is to learn a pretrained agent that can quickly adapt to testing tasks defined by rewards to maximize the sum of expected future rewards in a zero-shot or few-shot manner. This is also known as the two phases learning in unsupervised pretraining RL [20]. The current state-of-the-art methods maximize the mutual information $( I )$ between policy-conditioning variable $( w )$ and the behavior induced by the policy in terms of state visitation (s). ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f68eac69164735d80b29355484bcc41e2c622a79e1c5be30561d361cd28d199.jpg",
+        "text": "$$\n\\operatorname* { m a x } I ( s ; w ) = \\operatorname* { m a x } H ( w ) - H ( w \\vert s ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            150,
+            624,
+            166
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $w$ is sampled from a fixed distribution in practice as in DIAYN [17] and VISR [20]. The objective can then be simplified as max $- H ( w | s )$ . Due to it being intractable to directly maximize this negative conditional entropy, prior work propose to maximize the variational lower bound of the negative conditional entropy instead [7]. The training then amounts to learning a posterior of task variable conditioning on states $q ( w | s )$ . ",
+        "bbox": [
+            173,
+            169,
+            825,
+            239
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbdd27c40bbdcb8d3939b20e097c40c09c4188934d36bc24aa4c76a8626f0daf.jpg",
+        "text": "$$\n- H ( w | s ) \\geq \\mathbb { E } _ { s , w } \\left[ \\log q ( w | s ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            242,
+            602,
+            258
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Despite successful results in learning meaningful behaviors from reward-free interactions [e.g. 41, 18, 26, 17, 20], these methods suffer from insufficient exploration because they contain no explicit exploration. ",
+        "bbox": [
+            173,
+            261,
+            826,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another category considers the alternative direction of maximizing the mutual information [12]. ",
+        "bbox": [
+            173,
+            309,
+            800,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d03cf909fa6b740884fd3c56e1ecebc6400adf1be6c6333d7b59f5213643a023.jpg",
+        "text": "$$\n\\operatorname* { m a x } I ( s ; w ) = \\operatorname* { m a x } H ( s ) - H ( s | w ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            327,
+            620,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This intractable quantity can be similarly lowered bound by a variational approximation [7]. ",
+        "bbox": [
+            176,
+            345,
+            774,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a9ed49ba9e42952fee7c6bedb1df359e2579f714c49b3cebd129b2995986b4e1.jpg",
+        "text": "$$\nI ( s ; w ) \\geq \\mathbb { E } _ { s , w } \\left[ q _ { \\theta } ( s | w ) \\right] - \\mathbb { E } _ { s } \\left[ \\log p ( s ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            363,
+            635,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { E } _ { s } \\left[ \\log p ( s ) \\right]$ can then be approximated by a posterior of state given task variables $\\mathbb { E } _ { s } \\left[ \\log p ( s ) \\right] \\approx \\bar { \\mathbb { E } _ { s , w } } \\left[ \\log q ( s | w ) \\right]$ . Despite their successes, this category of methods do not explore sufficiently since the agent receives larger rewards for visiting known states than discovering new ones as theoretically and empirically evidenced by Campos et al. [12]. In addition, they have only been shown to work from explicit state-representations and it remains unclear how to modify to learning from pixels. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the next section, we introduce a new nonparametric unsupervised pre-training method for RL which addresses these issues and outperforms prior state-of-the-arts on challenging visual-domain RL benchmarks. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Unsupervised Active Pre-Training for RL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            532,
+            550,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We want to incentivize the agent with a reward $r _ { t }$ to maximize entropy in an abstract representation space. Prior work on maximizing entropy relies on estimating density of states which is challenging and non-trivial, instead, we take a two-step approach. First, we learn a mapping $f _ { \\theta } : R ^ { n s } \\to R ^ { n z }$ that maps state space to an abstract representation space first. Then, we propose a particle-based nonparametric approach to maximize the entropy by deploying state-of-the-art RL algorithms. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We introduce how to maximize entropy via particle-based approximation in Section 3.1, and describe how to learn representation from states in Section 3.2 ",
+        "bbox": [
+            173,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Particle-Based Entropy Maximization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            681,
+            477,
+            698
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our entropy maximization objective is built upon the nonparametric particle-based entropy estimator proposed by Singh et al. [55] and Beirlant [8] and has has been widely studied in statistics [28]. Its key idea is to measure the sparsity of the distribution by considering the distance between each sampled data point and its $k$ nearest neighbors. Concretely, assuming we have number of $n$ data points $\\{ z _ { i } \\} _ { i = 1 } ^ { n }$ from some unknown distribution, the particle-based approximation can be written as ",
+        "bbox": [
+            173,
+            707,
+            825,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4368d9b2553d86867bff7e587f59e079f410b34b239c77fb9605c1eda1cbfb35.jpg",
+        "text": "$$\nH _ { \\mathrm { p a r t i c l e } } ( z ) = - \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\log \\frac { k } { n \\mathrm { v } _ { i } ^ { k } } + b ( k ) \\propto \\sum _ { i = 1 } ^ { n } \\log \\mathrm { v } _ { i } ^ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            780,
+            671,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $b ( k )$ is a bias correction term that only depends on the hyperparameter $k$ , and $\\mathrm { v } _ { i } ^ { k }$ is the volume of the hypersphere of radius $\\| z _ { i } - z _ { i } ^ { ( k ) } \\|$ between $z _ { i }$ and its $k$ -th nearest neighbor $z _ { i } ^ { ( k ) } . \\parallel \\cdot \\parallel$ is the Euclidean distance. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3ee606dcdcbeeb9727b1ead649fe1bf2f3253687c2e0795ab7621c0fb0a2ecf.jpg",
+        "text": "$$\n\\mathrm { v } _ { i } ^ { k } = \\frac { \\| z _ { i } - z _ { i } ^ { ( k ) } \\| ^ { n _ { z } } \\cdot \\pi ^ { n _ { z } / 2 } } { \\Gamma \\left( n _ { \\mathcal { Z } } / 2 + 1 \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            872,
+            598,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/088a2e5327a5fc6614101c8e99926edea51d628f749e6def09ccd3359159faf0.jpg",
+        "image_caption": [
+            "Figure 2: Diagram of the proposed method APT. On the left shows the objective of APT, which is to maximize the expected reward and minimize the contrastive loss. The contrastive loss learns an abstract representation from observations induced by the policy. We propose a particle-based entropy maximization based reward function such that we can deploy state-of-the-art RL methods to maximize entropy in an abstraction space of the induced by the policy. On the right shows the idea of our particle-based entropy, which measures the distance between each data point and its $\\mathbf { k }$ nearest neighbors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            88,
+            810,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\Gamma$ is the gamma function. Intuitively, $\\mathrm { v } _ { i } ^ { k }$ reflects the sparsity around each particle and equation (1) is proportional to the average of the volumes around each particle. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By substituting equation (2) into equation (1), we can simplify the particle-based entropy estimation as a sum of the log of the distance between each particle and its $k$ -th nearest neighbor. ",
+        "bbox": [
+            174,
+            393,
+            823,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0eee36da3862b6b0f80d4dea48d70df5427d749017cc35137c966e8281f2b508.jpg",
+        "text": "$$\nH _ { \\mathrm { p a r t i c l e } } ( z ) \\propto \\sum _ { i = 1 } ^ { n } \\log \\| z _ { i } - z _ { i } ^ { ( k ) } \\| ^ { n z } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            425,
+            620,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Rather than using equation (3) as the entropy estimation, we find averaging the distance over all $k$ nearest neighbors leads to a more robust and stable result, yielding our estimation of the entropy. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a0ff3aac748e461631b6ccd4091fac5dc04473b696c1154506c6bf38572598b.jpg",
+        "text": "$$\nH _ { \\mathrm { p a r t i c l e } } ( z ) : = \\sum _ { i = 1 } ^ { n } \\log \\left( c + \\frac { 1 } { k } \\sum _ { z _ { i } ^ { ( j ) } \\in \\mathrm { N } _ { k } ( z _ { i } ) } \\| z _ { i } - z _ { i } ^ { ( j ) } \\| ^ { n \\ : z } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            498,
+            692,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { N } _ { k } ( \\cdot )$ denotes the $k$ nearest neighbors around a particle, $c$ is a constant for numerical stability (fixed to 1 in all our experiments). ",
+        "bbox": [
+            173,
+            559,
+            821,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can view the particle-based entropy in equation (4) as an expected reward with the reward function being $\\begin{array} { r } { r ( z _ { i } ) = \\log \\left( c + \\frac { 1 } { k } \\sum _ { z _ { i } ^ { ( j ) } \\in \\mathbb { N } _ { k } ( z _ { i } ) } \\| z _ { i } - z _ { i } ^ { ( j ) } \\| ^ { n _ { z } } \\right) } \\end{array}$ for each particle $z _ { i }$ . This makes it possible to deploy RL algorithms to maximize entropy, concretely, for a batch of transitions $\\{ ( s , a , s ^ { \\prime } ) \\}$ sampled from the replay buffer. We consider the representation of each $s ^ { \\prime }$ as a particle in the representation space and the reward function for each transition is given by ",
+        "bbox": [
+            173,
+            593,
+            826,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6f37d9eb51bebd8baabe56a25656d7b7678746b00a17747363de76c6f20778e2.jpg",
+        "text": "$$\nr ( s , a , s ^ { \\prime } ) = \\log \\left( c + \\frac { 1 } { k } \\sum _ { z ^ { ( j ) } \\in \\mathrm { N } _ { k } ( z = f _ { \\theta } ( s ) ) } \\| f _ { \\theta } ( s ) - z ^ { ( j ) } \\| ^ { n _ { z } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            674,
+            700,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to keep the rewards on a consistent scale, we normalize the intrinsic reward by dividing it by a running estimate of the mean of the intrinsic reward. See Figure 2 for illustration of the formulation. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Learning Contrastive Representations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            478,
+            789
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our aforementioned entropy maximization is modular of the representation learning method we choose to use, the representation learning part can be swapped out for different methods if necessary. However, for entropy maximization to work, the representation needs to contain a compressed representation of the state. Recent work, CURL [35], ATC [56] and SPR [52], show contrastive learning (with data augmentation) helps learn meaningful representations in RL. We choose contrastive representation learning since it maximally distinguishes an observation $s _ { t _ { 1 } }$ from alternative observations $s _ { t _ { 2 } }$ according to certain distance metric in representation space, we hypothesize is helpful for learning meaningful representations for our nearest neighbors based entropy maximization. Our contrastive learning is based on the contrastive loss from SimCLR [14], chosen for its simplicity. We also use the same set of image augmentations as in DrQ [33] consisting of small random shifts and color jitter. Concretely, we randomly sample a batch of states (images) from the replay buffer $\\{ s _ { i } \\} _ { i = 1 } ^ { n }$ . For each state $s _ { i }$ , we apply random data augmentation and obtain two randomly augmented views of the same state, denoted as key $s _ { i } ^ { k } = \\mathrm { a u g } ( s _ { i } )$ and query $s _ { i } ^ { v } = \\mathrm { a u g } ( s _ { i } )$ . The augmented observations are encoded into a small latent space using the encoder $z = f _ { \\theta } ( \\cdot )$ followed by a deterministic projection $h _ { \\phi } ( \\cdot )$ where a contrastive loss is applied. The goal of contrastive learning is to ensure that after the encoder and projection, $s _ { i } ^ { k }$ is relatively more close to $s _ { i } ^ { v }$ than any of the data points $\\{ s _ { j } ^ { k } , s _ { j } ^ { v } \\} _ { j = 1 , j \\neq i } ^ { n }$ ",
+        "bbox": [
+            173,
+            799,
+            826,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/935668030f6666f52cd7d558dd9e97b094b166f105abcba248e6b6dc4d1885bc.jpg",
+        "text": "$$\n\\underset { \\substack { \\theta , \\phi } } { \\mathrm { n i n } } - \\frac { 1 } { 2 n } \\sum _ { i = 1 } ^ { n } \\left[ \\log \\frac { \\exp ( h _ { \\phi } ( f _ { \\theta } ( s _ { i } ^ { k } ) ) ^ { T } h _ { \\phi } ( f _ { \\theta } ( s _ { i } ^ { v } ) ) ) } { \\sum _ { i = 1 } ^ { n } \\mathbb { I } _ { [ j \\neq i ] } ( \\exp ( h _ { \\phi } ( f _ { \\theta } ( s _ { i } ^ { k } ) ) ^ { T } h _ { \\phi } ( f _ { \\theta } ( s _ { j } ^ { k } ) ) ) + \\exp ( h _ { \\phi } ( f _ { \\theta } ( s _ { i } ^ { k } ) ) ^ { T } h _ { \\phi } ( f _ { \\theta } ( s _ { j } ^ { v } ) ) ) } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            218,
+            828,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following $\\mathrm { D r Q }$ , the representation encoder $f _ { \\theta } ( \\cdot )$ is implemented by the convolutional residual network followed by a fully-connected layer, a LayerNorm and a Tanh non-linearity. We decrease the output dimension of the fully-connected layer after the convnet from 50 to 15. We find it helps to use spectral normalization [39] to normalize the weights and use ELU [15] as the non-linearity in between convolutional layers. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1 positions our new approach with respect to existing ones. Figure 2 shows the resulting model. Training proceeds as in other algorithms maximizing extrinsic reward: by learning neural encoder $f$ and computing intrinsic reward $r$ and then trying to maximize this intrinsic return by training the policy. Algorithm 1 shows the pseudo-code of APT, we highlight the changes from DrQ to APT in color. ",
+        "bbox": [
+            173,
+            348,
+            825,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Training APT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            359,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/31387424e4bf48e6514204bfa608dd94b2150e6e394365c34ac3bc0852f730b6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">RandomlyInitialize f encoder RandomlyInitialize πand Qnetworks fore:=1, do</td></tr><tr><td colspan=\"3\">fort:=1,Tdo Receive observation st from environment</td></tr><tr><td colspan=\"3\">Take action at ~ π(*|st),receive observation St+1 and T from environment</td></tr><tr><td colspan=\"3\">D ←DU(st,at,t,st) {(si,ai,,s)}-1 ~D</td></tr><tr><td colspan=\"3\">Train neural encoder f on mini batch</td></tr><tr><td colspan=\"3\">for each i=1..N do</td></tr><tr><td colspan=\"3\">a~π(-|s)</td></tr><tr><td colspan=\"3\">Qi=Qe(s,ai)</td></tr><tr><td colspan=\"3\">Compute rAPr with equation (5)</td></tr><tr><td colspan=\"3\">yi ← rAPT +γQi</td></tr><tr><td colspan=\"3\">end</td></tr><tr><td colspan=\"3\">lossQ =∑(Q(si,ai)-yi)²</td></tr><tr><td colspan=\"3\">Gradient descent step on Q and π</td></tr><tr><td colspan=\"3\"></td></tr><tr><td colspan=\"3\">end end</td></tr></table>",
+        "bbox": [
+            173,
+            450,
+            812,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab5f6b8643f661e05a68f692b6362d8c137af10c9eb7cd7333ba0c25eb4037cb.jpg",
+        "table_caption": [
+            "Table 1: Methods for pre-training RL in reward-free setting. Exploration: the method can explore efficiently. Visual: the method works well in visual RL. Off-policy: the method is compatible with off-policy RL optimization. ⋆ means only in state-based RL. c(s) is count-based bonus. $\\psi ( s , a )$ : successor feature, $\\phi ( s )$ : state representation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>Objective</td><td>Visual</td><td>Exploration</td><td>Off-policy</td><td>Pre-Trained model</td></tr><tr><td>MaxEnt [22]</td><td>maxH(s)</td><td>×</td><td>三</td><td>X</td><td>π(a|s)</td></tr><tr><td>CBB [10]</td><td>maxEs[c(s)]</td><td>×</td><td></td><td></td><td>π(a|s)</td></tr><tr><td>MEPOL [42]</td><td>maxH(s)</td><td></td><td></td><td></td><td>π(a|s)</td></tr><tr><td>VISR [20]</td><td>max-H(z|s)</td><td>x&gt;</td><td></td><td>X</td><td>(s,2），(s)</td></tr><tr><td>DIAYN [17]</td><td>max-H(z|s)+H(a|z,s)</td><td>X</td><td>X</td><td>√</td><td>π(a|s,)</td></tr><tr><td>DADS [54]]</td><td>max H(s) -H(s|z)</td><td>X</td><td>X</td><td>√</td><td>π(a|s,2),q(s&#x27;/s,z)</td></tr><tr><td>EDL [12]</td><td>maxH(s) -H(s|2)</td><td>X</td><td></td><td>√</td><td>π(a|s,2)</td></tr><tr><td>APT</td><td>max H(s)</td><td>√</td><td>√</td><td>√</td><td>π(a|s),Q(s,a)</td></tr></table>",
+        "bbox": [
+            176,
+            770,
+            841,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "State Space Entropy Maximization. Maximizing entropy of policy has been widely studied in RL, from inverse RL [69] to optimal control [59, 60, 49] and actor-critic [19]. State space entropy maximization has been recently used as an exploration method by estimating density of states and maximizing entropy [22]. In Hazan et al. [22] they present provably efficient exploration algorithms under certain conditions. VAE [32] based entropy estimation has been deployed in lower dimensional observation space [36]. However, due to the difficulty of estimating density in high dimensional space such as Atari games, such parametric exploration methods struggle to work in more challenging visual domains. In contrast, our work turns to particle based entropy maximization in a contrastive representation space. Maximizing particle-based entropy has been shown to improved data efficiency in state-based RL as in MEPOL [42]. However, MEPOL’s entropy estimation depends on importance sampling and the optimization based on on-policy RL algorithms, hindering further applications to challenging visual domains. MEPOL also assumes having access to the semantic information of the state, making it infeasible and not obvious how to modify it to work from pixels. In contrast, our method is compatible with deploying state-of-the-art off-policy RL and representation learning algorithms to maximize entropy. Nonparametric entropy maximization has been studied in goal conditioned RL [66]. Pitis et al. [47] proposes maximizing entropy of achieved goals and demonstrates significantly improved success rates in long horizon goal conditioned tasks. The work by Badia et al. [6] also considers $\\mathbf { k }$ -nearest neighbor based count bonus to encourage exploration, yielding improved performance in Atari games. K-nearest neighbor based exploration is shown to improve exploration and data efficiency in model-based RL [57]. Concurrently, it has been shown to be an effective unsupervised pre-training objective for transferring learning in RL [13], their large scale experiments further demonstrate the effectiveness of unsupervised pre-training. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            430
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Data Efficient RL. To improve upon the sample efficiency of deep RL methods, various methods have been proposed: Kaiser et al. [30] introduce a model-based agent (SimPLe) and show that it compares favorably to standard RL algorithms when data is limited. Hessel et al. [25], Kielak [31], van Hasselt et al. [61] show combining existing RL algorithms (Rainbow) can boost data efficiency. Data augmentation has also been shown to be effective for improving data efficiency in vision-based RL [34, 33]. Temporal contrastive learning combined with model-based learning has been shown to boost data efficiency [52]. Combining contrastive loss with RL has been shown to improve data efficiency in CPC [24] despite only marginal gains. CURL [35] show substantial data-efficiency gains while follow-up results from Kostrikov et al. [33] suggest that most of the benefits come from its use of image augmentation. Contrastive loss has been shown to learn useful pretrained representations when training on expert demonstration [56], however in our work the agent has to explore the world itself and exploit collect experience. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised Pre-Training RL. A number of recent works have sought to improve reinforcement learning via the addition of an unsupervised pretraining stage, in which the agent improves its representations prior to beginning learning on the target task. One common approach has been to allow the agent a period of fully-unsupervised interaction with the environment during which the agent is trained to learn a set of skills associated with different paths through the environment, as in DIAYN [17], Proto-RL [67], MUSIC [68], APS [37], and VISR [20]. Others have proposed to use self-supervised objectives to generate intrinsic rewards encouraging agents to visit new states, e.g., Pathak et al. [46] use the disagreement between an ensemble of latent-space dynamics models. However, our work is trained to maximize the entropy of the states induced by the policy. By visiting any state where the agent might be rewarded in a subsequent RL task, our work performs better or comparably well as other more complex and specialized state-of-the-art methods. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            266,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We test APT in DeepMind Control Suite [DMControl; 58] and the Atari suite [9]. During the the long period of pre-training with environment rewards removed, we use $\\mathrm { D r Q }$ to maximize the entropy maximization reward defined in equation (5). The pre-trained value function $Q ( s , a )$ is fine-tuned to maximize task specific reward after being exposing to environment rewards during testing period. For our DeepMind control suite and Atari games experiments, we largely follow $\\mathrm { D r Q }$ , except we perform two gradient steps per environment step instead of one. Our ablation studies confirm that these changes are not themselves responsible for our performance. Kornia [50] is used for efficient GPU-based data augmentations. Our model is implemented in Numpy [21] and PyTorch [45]. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "APT outperforms prior from scratch SOTA RL on DMControl. We evaluate the performance of different methods by computing the average success rate and episodic return at the end of training. ",
+        "bbox": [
+            171,
+            126,
+            825,
+            154
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe8c8603ef53ddcac9640efceddfb07e4de9b9e5b04fe0e0e9b0cc4599df221b.jpg",
+        "image_caption": [
+            "Figure 3: Results of different methods in environments from DMControl. All curves are the average of three runs with different seeds, and the shaded areas are standard errors of the mean. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            165,
+            828,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The agent is allowed a long unsupervised pre-training phase (5M steps), followed by a short test phase exposing to downstream reward, during which the pre-trained model is fine-tuned. We follow the evaluation setting of DrQ and test APT on a subset of DMControl suite, which includes training Walker, Cheetah, Hopper for various locomotion tasks. Models are pre-trained on Cheetah, Hopper, and Walker, and subsequently fine-tuned on respective downstream tasks. We additionally design more challenging sparse reward tasks where the robot is required to accomplish tasks guided only by sparse feedback signal. The reason we opted to design new sparse reward tasks is to have more diverse downstream tasks. As far as we know, there is only one Cartpole Swingup Sparse that is a CartPole based sparse reward task. Due to its 2D nature being quite limited, we eventually decided to design distinguishable downstream tasks based on a little bit more complex environment, e.g. Hopper Jump etc. The details of the tasks are included in the supplementary material. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The learning process of RL agents becomes highly inefficient in sparse supervision tasks when relying on standard exploration techniques. This issue can be alleviated by introducing intrinsic motivation, i.e., denser reward signals that can be automatically computed, one approach that works well in high dimensional setting is count-based exploration [38, 44, 38]. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            726
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results are presented in Figure 3, APT significantly outperforms SOTA training from scratch (DrQ from scratch) and SOTA exploration method (count-based bonus) on every task. With only a few number of environment interactions, APT quickly adapt to downstream tasks and achieves higher return much more quicker than prior state-of-the-art RL algorithms. Notably, on the sparse reward tasks that are extremely difficult for training from scratch, APT yields significantly higher data efficiency and asymptotic performance. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "APT outperforms from scratch SOTA RL in Atari. We test APT on the sample-efficient Atari setting [30, 61] which consists of the 26 easiest games in the Atari suite (as judged by above random performance for their algorithm). ",
+        "bbox": [
+            174,
+            820,
+            825,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We follow the evaluation setting in VISR, agents are allowed a long unsupervised training phase (250M steps) without access to rewards, followed by a short test phase with rewards. The test phase contains 100K environment steps – equivalent to $4 0 0 \\mathrm { k }$ frames, or just under two hours – compared to the typical standard of 500M environment steps, or roughly 39 days of experience. We normalize the episodic return with respect to expert human scores to account for different scales of scores in each game, as done in previous works. The human-normalized scores (HNS) of an agent on a game is calculated as agent score−random scorehuman score−random score and aggregated across games by mean or median. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            151
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A full list of scores and aggregate metrics on the Atari 26 subset is presented in Table 2. The results on the full 57 Atari games suite is presented in supplementary material. For consistency with previous works, we report human and random scores from [25]. In the data-limited setting, APT achieves super-human performance on eight games and achieves scores higher than previous state-of-the-arts. In the full suite setting, APT achieves super-human performance on 15 games, compared to a maximum of 12 for any previous methods and achieves scores significantly higher than any previous methods. ",
+        "bbox": [
+            173,
+            156,
+            825,
+            253
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/653d1dcc419e62bf73c9025320d672fc1af87f6b583707697b022e01d8653251.jpg",
+        "table_caption": [
+            "Table 2: Performance of different methods on the 26 Atari games considered by [30] after 100K environment steps. The results are recorded at the end of training and averaged over 10 random seeds for APT. APT outperforms prior methods on all aggregate metrics, and exceeds expert human performance on 7 out of 26 games while using a similar amount of experience. Prior work has reported different numbers for some of the baselines, particularly SimPLe and DQN. To be rigorous, we pick the best number for each game across the tables reported in van Hasselt et al. [61] and Kielak [31]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Game</td><td>Random</td><td>Human</td><td>SimPLe</td><td>DER</td><td>CURL</td><td>DrQ</td><td>SPR</td><td>VISR</td><td>APT (ours)</td></tr><tr><td>Alien</td><td>227.8</td><td>7127.7</td><td>616.9</td><td>739.9</td><td>558.2</td><td>771.2</td><td>801.5</td><td>364.4</td><td>2614.8</td></tr><tr><td>Amidar</td><td>5.8</td><td>1719.5</td><td>88.0</td><td>188.6</td><td>142.1</td><td>102.8</td><td>176.3</td><td>186.0</td><td>211.5</td></tr><tr><td>Assault</td><td>222.4</td><td>742.0</td><td>527.2</td><td>431.2</td><td>600.6</td><td>452.4</td><td>571.0</td><td>12091.1</td><td>891.5</td></tr><tr><td>Asterix</td><td>210.0</td><td>8503.3</td><td>1128.3</td><td>470.8</td><td>734.5</td><td>603.5</td><td>977.8</td><td>6216.7</td><td>185.5</td></tr><tr><td>Bank Heist</td><td>14.2</td><td>753.1</td><td>34.2</td><td>51.0</td><td>131.6</td><td>168.9</td><td>380.9</td><td>71.3</td><td>416.7</td></tr><tr><td>BattleZone</td><td>2360.0</td><td>37187.5</td><td>5184.4</td><td>10124.6</td><td>14870.0</td><td>12954.0</td><td>16651.0</td><td>7072.7</td><td>7065.1</td></tr><tr><td>Boxing</td><td>0.1</td><td>12.1</td><td>9.1</td><td>0.2</td><td>1.2</td><td>6.0</td><td>35.8</td><td>13.4</td><td>21.3</td></tr><tr><td>Breakout</td><td>1.7</td><td>30.5</td><td>16.4</td><td>1.9</td><td>4.9</td><td>16.1</td><td>17.1</td><td>17.9</td><td>10.9</td></tr><tr><td>ChopperCommand</td><td>811.0</td><td>7387.8</td><td>1246.9</td><td>861.8</td><td>1058.5</td><td>780.3</td><td>974.8</td><td>800.8</td><td>317.0</td></tr><tr><td>Crazy Climber</td><td>10780.5</td><td>23829.4</td><td>62583.6</td><td>16185.2</td><td>12146.5</td><td>20516.5</td><td>42923.6</td><td>49373.9</td><td>44128.0</td></tr><tr><td>Demon Attack</td><td>107805</td><td>35829.4</td><td>62583.6</td><td>16185.3</td><td>12146.5</td><td>20516.5</td><td>42923.6</td><td>8994.9</td><td>5071.8</td></tr><tr><td>Freeway</td><td>0.0</td><td>29.6</td><td>20.3</td><td>27.9</td><td>26.7</td><td>9.8</td><td>24.4</td><td>-12.1</td><td>29.9</td></tr><tr><td>Frostbite</td><td>65.2</td><td>4334.7</td><td>254.7</td><td>866.8</td><td>1181.3</td><td>331.1</td><td>1821.5</td><td>230.9</td><td>1796.1</td></tr><tr><td>Gopher</td><td>257.6</td><td>2412.5</td><td>771.0</td><td>349.5</td><td>669.3</td><td>636.3</td><td>715.2</td><td>498.6</td><td>2590.4</td></tr><tr><td>Hero</td><td>1027.0</td><td>30826.4</td><td>2656.6</td><td>6857.0</td><td>6279.3</td><td>3736.3</td><td>7019.2</td><td>663.5</td><td>6789.1</td></tr><tr><td>Jamesbond</td><td>29.0</td><td>302.8</td><td>125.3</td><td>301.6</td><td>471.0</td><td>236.0</td><td>365.4</td><td>484.4</td><td>356.1</td></tr><tr><td>Kangaroo</td><td>52.0</td><td>3035.0</td><td>323.1</td><td>779.3</td><td>872.5</td><td>940.6</td><td>3276.4</td><td>1761.9</td><td>412.0</td></tr><tr><td>Krull</td><td>1598.0</td><td>2665.5</td><td>4539.9</td><td>2851.5</td><td>4229.6</td><td>4018.1</td><td>2688.9</td><td>3142.5</td><td>2312.0</td></tr><tr><td>Kung Fu Master</td><td>258.5</td><td>22736.3</td><td>17257.2</td><td>14346.1</td><td>14307.8</td><td>9111.0</td><td>13192.7</td><td>16754.9</td><td>17357.0</td></tr><tr><td>Ms Pacman</td><td>307.3</td><td>6951.6</td><td>1480.0</td><td>1204.1</td><td>1465.5</td><td>960.5</td><td>1313.2</td><td>558.5</td><td>2827.1</td></tr><tr><td>Pong</td><td>-20.7</td><td>14.6</td><td>12.8</td><td>-19.3</td><td>-16.5</td><td>-8.5</td><td>-5.9</td><td>-26.2</td><td>-8.0</td></tr><tr><td>Private Eye</td><td>24.9</td><td>69571.3</td><td>58.3</td><td>97.8</td><td>218.4</td><td>-13.6</td><td>124.0</td><td>98.3</td><td>96.1</td></tr><tr><td>Qbert</td><td>163.9</td><td>13455.0</td><td>1288.8</td><td>1152.9</td><td>1042.4</td><td>854.4</td><td>669.1</td><td>666.3</td><td>17671.2</td></tr><tr><td>Road Runner</td><td>11.5</td><td>7845.0</td><td>5640.6</td><td>9600.0</td><td>5661.0</td><td>8895.1</td><td>14220.5</td><td>6146.7</td><td>4782.1</td></tr><tr><td>Seaquest</td><td>68.4</td><td>42054.7</td><td>683.3</td><td>354.1</td><td>384.5</td><td>301.2</td><td>583.1</td><td>706.6</td><td>2116.7</td></tr><tr><td>Up N Down</td><td>533.4</td><td>11693.2</td><td>3350.3</td><td>2877.4</td><td>2955.2</td><td>3180.8</td><td>28138.5</td><td>10037.6</td><td>8289.4</td></tr><tr><td>Mean HNS</td><td>0.000</td><td>1.000</td><td>44.3</td><td>28.5</td><td>38.1</td><td>35.7</td><td>70.4</td><td>64.31</td><td>69.55</td></tr><tr><td>Median HNS # Superhuman</td><td>0.000 0</td><td>1.000 N/A</td><td>14.4 2</td><td>16.1 2</td><td>17.5 2</td><td>26.8 2</td><td>41.5 7</td><td>12.36 6</td><td>47.50 7</td></tr></table>",
+        "bbox": [
+            171,
+            345,
+            825,
+            671
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised pre-training on top of $\\mathrm { D r Q }$ leads a significant increase in performance(a $54 \\%$ increase in median score, a $73 \\%$ increase in mean score, and 5 more games with human-level performance), surpassing DQN which trained on hundreds of millions of sampling steps. ",
+        "bbox": [
+            178,
+            690,
+            823,
+            732
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Compared with SPR [52] which is a recent state-of-the-art model-based data-efficient algorithm, APT achieves comparable mean and median scores. The SPR is based on Rainbow which combines more advances than DrQ which is significantly simpler. While the representation of SPR is also learned by contrastive learning, it trains a model-based dynamic to predict its own latent state representations multiple steps into the future. This temporal representation learning, as illustrated in the SPR paper, contributes to its impressive results compared with standard contrastive representation learning. We believe that it is possible to combine temporal contrastive representation learning of SPR with the effective nonparametric entropy maximization of APT, which is an interesting future direction. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "APT outperforms prior unsupervised RL. Despite there being many different proposed unsupervised RL methods, their successes are only demonstrated in simple state based environments. Prior works train the agent for a period of fully-unsupervised interaction with the environment, during which the agent is trained to learn a set of skills associated with different paths through the environment, as in DIAYN [17] and VIC [18], or to maximize the diversity of the states it encounters, as in MEPOL [42] and Hazan et al. [22]. Until recently, VISR [20] achieves improved results in Atari games using pixels as input based using a successor feature based approach. In order to compare with prior unsupervised RL methods, we choose DIAYN due to it being based on mutual information maximization and its reported high performance in state-based RL, and MEPOL due to it being based on entropy maximization. We implement them to take pixels as input in Atari games. Our implementation was checked against publicly available code and we made a best effort attempt to tune the algorithms in Atari games. We test two variants of DIAYN and MEPOL, using or not using contrastive representation learning as in APT. In order to ensure a fair comparison, we test a variant of APT without contrastive representation learning. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The aggregated results are presented in Table 3, APT significantly outperforms prior state-based unsupervised RL algorithms DIAYN and MEPOL. Both baselines benefit from contrastive representation learning, but their scores are still significantly lower than APT’s score, confirming that the effectiveness of the off-policy entropy maximization in APT. Compared with the state-of-the-art method in Atari VISR, APT achieves significantly higher median score despite having a lower mean score. From the scores breakdown presented in supplementary file, APT performs significantly better than VISR in hard exploration games, while VISR achieves higher scores in dense reward games. We attribute this to that maximizing state entropy leads to more exploratory behavior while successor features enables quicker adaptation for dense reward feedback. It is possible to combine VISR and APT to have the best of both worlds, which we leave as a future work. ",
+        "bbox": [
+            174,
+            234,
+            517,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e3821fb5bc98213ec828daf2aabccd231e2d6753ab59998ca339f39ed46f4878.jpg",
+        "table_caption": [
+            "Table 3: Evaluation in Atari games. The amount of RL interaction utilized is 100K. M dn is the median of human-normalized scores, $M$ is the mean and $> H$ is the number of games with human-level performance. CL denotes training representation encoder using contrastive learning and data augmentation. On each subset, we mark as bold the highest score. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">26 Game Subset</td><td colspan=\"3\">Full 57 Games</td></tr><tr><td>Algorithm</td><td>Mdn</td><td>M</td><td></td><td>&gt;H Mdn</td><td>M</td><td>&gt;H</td></tr><tr><td>CBB</td><td>1.23</td><td>21.94</td><td>3</td><td></td><td></td><td>1</td></tr><tr><td>MEPOL</td><td>0.34</td><td>17.94</td><td>2</td><td>一</td><td></td><td>1</td></tr><tr><td>DIAYN</td><td>1.34</td><td>25.39</td><td>2</td><td>2.95</td><td>23.90</td><td>6</td></tr><tr><td>CBB w/CL</td><td>1.78</td><td>17.34</td><td>2</td><td>1</td><td>1</td><td>1</td></tr><tr><td>MEPOL W/ CL</td><td>1.05</td><td>21.78</td><td>3</td><td>1</td><td>一</td><td></td></tr><tr><td>DIAYN w/ CL</td><td>1.76</td><td>28.44</td><td>2</td><td>3.28</td><td>25.14</td><td>6</td></tr><tr><td>VISR</td><td>9.50</td><td>128.07</td><td>7</td><td>6.81</td><td>102.31</td><td>11</td></tr><tr><td>APT w/o CL</td><td>21.23</td><td>28.12</td><td>3</td><td>28.65</td><td>41.12</td><td>9</td></tr><tr><td>APT</td><td>47.50</td><td>69.55</td><td>7</td><td>33.41</td><td>47.73</td><td>12</td></tr></table>",
+        "bbox": [
+            532,
+            349,
+            825,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ablation study. We conduct several ablation studies to measure the contribution of each component in our method. We test two variants of APT that use the same number of gradient steps per environment step and use the same activation function as in DrQ. Another variant of APT is based on randomly selected neighbors to compute particle-based entropy. ",
+        "bbox": [
+            173,
+            505,
+            825,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also test a variant of APT that use a fixed randomly initialized encoder to study the impact of representation learning. Table 4 shows the performance of each variant of APT. Increasing gradient steps of updating value function from 1 to 2 and using ELU activation function yield higher scores. Using $\\mathbf { k }$ -nearest neighbors is crucial to high scores, we believe the reason is randomly selected neighbors do not provide necessary incentive to explore. Using randomly initialized convolutional encoder downgrades performance significantly but still achieve higher score than $\\mathrm { D r Q }$ , indicating our particlebased entropy maximization is robust and powerful. ",
+        "bbox": [
+            174,
+            560,
+            531,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/5961038a625fc2993b0177ba0ae604d7bddc75cc5a4dca60c29de226fc7e5b20.jpg",
+        "table_caption": [
+            "Table 4: Scores on the 26 Atari games under consideration for variants of APT. Scores are averaged over 3 random seeds. All variants listed here use data augmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Variant</td><td>Human-Normalized Score median mean</td></tr><tr><td>APT</td><td>47.50</td></tr><tr><td>APT w/o optim change</td><td>41.50</td></tr><tr><td>APT w/o arch change</td><td>45.71</td></tr><tr><td>APT w/ rand neighbor</td><td>20.80 33.24</td></tr><tr><td>APT w/ fixed encoder</td><td>24.97 41.08</td></tr></table>",
+        "bbox": [
+            545,
+            627,
+            828,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Contrastive learning representation has   \nbeen shown to have the “uniformity on the hypersphere” property [65], this leads to the question that whether maximum entropy exploration in state space is important. To study this question, we have a variant of APT “Pos Reward APT” which receives a simple positive do not die signal but no particle-based entropy reward. We ran the experiments on MsPacman, we reduced the pretraining phase to 5M steps to reduce computation cost. The evaluation metrics are the number of ram states visited using [2] and the downstream zero shot performance on Atari game. APT visits nearly 27 times more unique ram states than “Pos Reward APT”, showing that the entropy intrinsic reward is indispensable for exploration. In downstream task evaluation over 3 random seeds, “Pos Reward APT $@ 0 ^ { , 9 }$ achieves reward 363.7, “APT $@ 0 ^ { , , }$ achieves reward 687.1, showing that the “do not die” signal is insufficient for exploration or learning pretrained behaviors and representations. ",
+        "bbox": [
+            173,
+            733,
+            826,
+            897
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We consider a variant of APT that re-initialize the head of pretrained actor-critic. We have run experiments in five different Atari games, as shown in Table 5, pretrained heads ",
+        "bbox": [
+            173,
+            92,
+            356,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/b68be7dda942fc9a5235914337cfeffdc26ef3b548120593c23cf54da4b8b6ba.jpg",
+        "table_caption": [
+            "Table 5: Scores on 5 Atari games under consideration for different variants of fine-tuning. Scores are averaged over 3 random seeds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Mean Reward (3 seeds)</td><td>Alien</td><td>Freeway</td><td>Qbert</td><td>Private Eye</td><td>MsPacman</td></tr><tr><td>APT (pretrained head)</td><td>2614.8</td><td>29.9</td><td>17671.2</td><td>96.1</td><td>2827.1</td></tr><tr><td>APT (random head)</td><td>1755.0</td><td>15.2</td><td>2138.3</td><td>61.3</td><td>1724.9</td></tr></table>",
+        "bbox": [
+            369,
+            127,
+            820,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "perform better than randomly initialized heads in 4 out of 5 games. The experiments demonstrate that finetuning from a pretrained actor-critic head accelerates learning. However, we believe that which one of the two is better depends on the alignment between downstream reward and intrinsic reward. It would be interesting to study how to better leverage downstream reward to finetune the pretrained model. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            292,
+            292
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitation: The fine-tuning strategy employed here (when combined with a value function) works best when the intrinsic and extrinsic rewards being of a similar scale. We believe the discrepancy between intrinsic reward scale and downstream reward scale possibly explain the suboptimal performance of APT in dense reward games. This is an interesting future direction to further improve APT, we hypothesize that reinitializing behaviors part (actor-critic heads) might be useful if the downstream reward scale is very different from pretraining reward scale. One of the principled ways could be adaptive normalization [62], it is an interesting future direction. One challenge of our method is the non-stationarity of the intrinsic reward, being non additive reward poses an interesting challenge for reinforcement learning methods. While our method outperforms training from scratch and prior works, we believe designing better optimization RL methods for maximizing our intrinsic reward can lead to more significant improvement. ",
+        "bbox": [
+            173,
+            308,
+            825,
+            459
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conclusion: A new unsupervised pre-training method for RL is introduced to address reward-free pre-training for visual RL, allowing the same task-agnostic pre-trained model to successfully tackle a broad set of RL tasks. Our major contribution is introducing a practical intrinsic reward derived from particle-based entropy maximization in abstract representation space. Empirical study on DMControl suite and Atari games show our method dramatically improves performance on tasks that are extremely difficult for training from scratch. Our method achieves the results of fully supervised canonical RL algorithms using a small fraction of total samples and outperforms data-efficient supervised RL methods. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            584
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For future work, there are a few ways in which our method can be improved. The long pre-training phase in our work is computationally intensive, since the exhaustive search and exploration is of high sample complexity. One way to remedy this is by combining our method with successful model-based RL and search approaches to reduce sample complexity. Furthermore, fine-tuning the whole pretrained model can make it prone to catastrophic forgetting. As such, it is worth studying alternative methods to leverage the pre-trained models such as keeping the pretrained model unchanged and combine it with a randomly initialized model. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Acknowledgment ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            707,
+            349,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by DARPA Data-Driven Discovery of Models (D3M) program. We would like to thank Misha Laskin, Olivia Watkins, Qiyang Li, Lerrel Pinto, Kimin Lee and other members at RLL and BAIR for insightful discussion and giving constructive comments. We would also like to thank anonymous reviewers for their helpful feedback for previous versions of our work. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            813,
+            266,
+            829
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] I. Akkaya, M. Andrychowicz, M. Chociej, M. Litwin, B. McGrew, A. Petron, A. Paino, M. Plappert, G. Powell, R. Ribas, et al. Solving rubik’s cube with a robot hand. arXiv preprint arXiv:1910.07113, 2019.   \n[2] A. Anand, E. Racah, S. Ozair, Y. Bengio, M. Côté, and R. D. Hjelm. Unsupervised state representation learning in atari. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 8766–8779, 2019. [3] M. Andrychowicz, D. Crow, A. Ray, J. Schneider, R. Fong, P. Welinder, B. McGrew, J. Tobin, P. Abbeel, and W. Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5048–5058, 2017. [4] J. L. Ba, J. R. Kiros, and G. E. Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. [5] A. P. Badia, B. Piot, S. Kapturowski, P. Sprechmann, A. Vitvitskyi, Z. D. Guo, and C. Blundell. Agent57: Outperforming the atari human benchmark. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 507–517. PMLR, 2020.   \n[6] A. P. Badia, P. Sprechmann, A. Vitvitskyi, D. Guo, B. Piot, S. Kapturowski, O. Tieleman, M. Arjovsky, A. Pritzel, A. Bolt, and C. Blundell. Never give up: Learning directed exploration strategies. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. [7] D. Barber and F. V. Agakov. The im algorithm: A variational approach to information maximization. In Advances in neural information processing systems, 2003. [8] J. Beirlant. Nonparametric entropy estimation: An overview. International Journal of the Mathematical Statistics Sciences, 6:17–39, 1997.   \n[9] M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   \n[10] M. G. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pages 1471–1479, 2016.   \n[11] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   \n[12] V. Campos, A. Trott, C. Xiong, R. Socher, X. Giró-i-Nieto, and J. Torres. Explore, discover and learn: Unsupervised discovery of state-covering skills. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 1317–1327. PMLR, 2020.   \n[13] V. Campos, P. Sprechmann, S. S. Hansen, A. Barreto, C. Blundell, A. Vitvitskyi, S. Kapturowski, and A. P. Badia. Coverage as a principle for discovering transferable behavior in reinforcement learning, 2021.   \n[14] T. Chen, S. Kornblith, M. Norouzi, and G. E. Hinton. A simple framework for contrastive learning of visual representations. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 1597–1607. PMLR, 2020.   \n[15] D. Clevert, T. Unterthiner, and S. Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings, 2016.   \n[16] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota, 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1423.   \n[17] B. Eysenbach, A. Gupta, J. Ibarz, and S. Levine. Diversity is all you need: Learning skills without a reward function. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   \n[18] K. Gregor, D. J. Rezende, and D. Wierstra. Variational intrinsic control. arXiv preprint arXiv:1611.07507, 2016.   \n[19] T. Haarnoja, A. Zhou, P. Abbeel, and S. Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmässan, Stockholm, Sweden, July 10-15, 2018, volume 80 of Proceedings of Machine Learning Research, pages 1856–1865. PMLR, 2018.   \n[20] S. Hansen, W. Dabney, A. Barreto, D. Warde-Farley, T. V. de Wiele, and V. Mnih. Fast task inference with variational intrinsic successor features. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[21] C. R. Harris, K. J. Millman, S. J. van der Walt, R. Gommers, P. Virtanen, D. Cournapeau, E. Wieser, J. Taylor, S. Berg, N. J. Smith, et al. Array programming with numpy. Nature, 585 (7825):357–362, 2020.   \n[22] E. Hazan, S. M. Kakade, K. Singh, and A. V. Soest. Provably efficient maximum entropy exploration. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 2681–2691. PMLR, 2019.   \n[23] K. He, H. Fan, Y. Wu, S. Xie, and R. B. Girshick. Momentum contrast for unsupervised visual representation learning. In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2020, Seattle, WA, USA, June 13-19, 2020, pages 9726–9735. IEEE, 2020. doi: 10.1109/CVPR42600.2020.00975.   \n[24] O. J. Hénaff. Data-efficient image recognition with contrastive predictive coding. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 4182–4192. PMLR, 2020.   \n[25] M. Hessel, J. Modayil, H. van Hasselt, T. Schaul, G. Ostrovski, W. Dabney, D. Horgan, B. Piot, M. G. Azar, and D. Silver. Rainbow: Combining improvements in deep reinforcement learning. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pages 3215–3222. AAAI Press, 2018.   \n[26] R. Houthooft, X. Chen, Y. Duan, J. Schulman, F. D. Turck, and P. Abbeel. VIME: variational information maximizing exploration. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pages 1109–1117, 2016.   \n[27] E. T. Jaynes. Information theory and statistical mechanics. Physical review, 106(4):620, 1957.   \n[28] J. Jiao, W. Gao, and Y. Han. The nearest neighbor information estimator is adaptively near minimax rate-optimal. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal, Canada, pages 3160–3171, 2018.   \n[29] R. Julian, B. Swanson, G. S. Sukhatme, S. Levine, C. Finn, and K. Hausman. Never stop learning: The effectiveness of fine-tuning in robotic reinforcement learning. arXiv e-prints, pages arXiv–2004, 2020.   \n[30] L. Kaiser, M. Babaeizadeh, P. Milos, B. Osinski, R. H. Campbell, K. Czechowski, D. Erhan, C. Finn, P. Kozakowski, S. Levine, A. Mohiuddin, R. Sepassi, G. Tucker, and H. Michalewski. Model based reinforcement learning for atari. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[31] K. Kielak. Do recent advancements in model-based deep reinforcement learning really improve data efficiency? arXiv preprint arXiv:2003.10181, 2020.   \n[32] D. P. Kingma and M. Welling. Auto-encoding variational bayes. In 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, 2014.   \n[33] I. Kostrikov, D. Yarats, and R. Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649, 2020.   \n[34] M. Laskin, K. Lee, A. Stooke, L. Pinto, P. Abbeel, and A. Srinivas. Reinforcement learming with augmented data. arXiv:2004.14990, 2020.   \n[35] M. Laskin, A. Srinivas, and P. Abbeel. CURL: contrastive unsupervised representations for reinforcement learning. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 5639–5650. PMLR, 2020.   \n[36] L. Lee, B. Eysenbach, E. Parisotto, E. Xing, S. Levine, and R. Salakhutdinov. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274, 2019.   \n[37] H. Liu and P. Abbeel. Aps: Active pretraining with successor features. In International Conference on Machine Learning, pages 6736–6747. PMLR, 2021.   \n[38] M. C. Machado, M. G. Bellemare, and M. Bowling. Count-based exploration with the successor representation. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020, pages 5125–5133. AAAI Press, 2020.   \n[39] T. Miyato, T. Kataoka, M. Koyama, and Y. Yoshida. Spectral normalization for generative adversarial networks. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018.   \n[40] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.   \n[41] S. Mohamed and D. J. Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 2125–2133, 2015.   \n[42] M. Mutti, L. Pratissoli, and M. Restelli. A policy gradient method for task-agnostic exploration. arXiv preprint arXiv:2007.04640, 2020.   \n[43] A. v. d. Oord, Y. Li, and O. Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.   \n[44] G. Ostrovski, M. G. Bellemare, A. van den Oord, and R. Munos. Count-based exploration with neural density models. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pages 2721–2730. PMLR, 2017.   \n[45] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Köpf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 8024–8035, 2019.   \n[46] D. Pathak, D. Gandhi, and A. Gupta. Self-supervised exploration via disagreement. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 5062–5071. PMLR, 2019.   \n[47] S. Pitis, H. Chan, S. Zhao, B. Stadie, and J. Ba. Maximum entropy gain exploration for long horizon multi-goal reinforcement learning. In International Conference on Machine Learning, pages 7750–7761. PMLR, 2020.   \n[48] M. L. Puterman. Markov decision processes: discrete stochastic dynamic programming. John Wiley &amp; Sons, 2014.   \n[49] K. Rawlik, M. Toussaint, and S. Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. Proceedings of Robotics: Science and Systems VIII, 2012.   \n[50] E. Riba, D. Mishkin, D. Ponsa, E. Rublee, and G. Bradski. Kornia: an open source differentiable computer vision library for pytorch. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 3674–3683, 2020.   \n[51] J. Schrittwieser, I. Antonoglou, T. Hubert, K. Simonyan, L. Sifre, S. Schmitt, A. Guez, E. Lockhart, D. Hassabis, T. Graepel, et al. Mastering atari, go, chess and shogi by planning with a learned model. arXiv preprint arXiv:1911.08265, 2019.   \n[52] M. Schwarzer, A. Anand, R. Goel, R. D. Hjelm, A. Courville, and P. Bachman. Data-efficient reinforcement learning with self-predictive representations. In International Conference on Learning Representations, 2021.   \n[53] C. E. Shannon. A mathematical theory of communication. The Bell system technical journal, 27(3):379–423, 1948.   \n[54] A. Sharma, S. Gu, S. Levine, V. Kumar, and K. Hausman. Dynamics-aware unsupervised discovery of skills. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[55] H. Singh, N. Misra, V. Hnizdo, A. Fedorowicz, and E. Demchuk. Nearest neighbor estimates of entropy. American journal of mathematical and management sciences, 23(3-4):301–321, 2003.   \n[56] A. Stooke, K. Lee, P. Abbeel, and M. Laskin. Decoupling representation learning from reinforcement learning. arXiv preprint arXiv:2009.08319, 2020.   \n[57] R. Y. Tao, V. François-Lavet, and J. Pineau. Novelty search in representational space for sample efficient exploration. arXiv preprint arXiv:2009.13579, 2020.   \n[58] Y. Tassa, S. Tunyasuvunakool, A. Muldal, Y. Doron, S. Liu, S. Bohez, J. Merel, T. Erez, T. Lillicrap, and N. Heess. dm_control: Software and tasks for continuous control. arXiv preprint arXiv:2006.12983, 2020.   \n[59] E. Todorov. General duality between optimal control and estimation. In 2008 47th IEEE Conference on Decision and Control, pages 4286–4292. IEEE, 2008.   \n[60] M. Toussaint. Robot trajectory optimization using approximate inference. In Proceedings of the 26th Annual International Conference on Machine Learning, ICML 2009, Montreal, Quebec, Canada, June 14-18, 2009, volume 382 of ACM International Conference Proceeding Series, pages 1049–1056. ACM, 2009. doi: 10.1145/1553374.1553508.   \n[61] H. van Hasselt, M. Hessel, and J. Aslanides. When to use parametric models in reinforcement learning? In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 14322–14333, 2019.   \n[62] H. P. van Hasselt, A. Guez, M. Hessel, V. Mnih, and D. Silver. Learning values across many orders of magnitude. Advances in Neural Information Processing Systems, 29:4287–4295, 2016.   \n[63] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5998–6008, 2017.   \n[64] O. Vinyals, I. Babuschkin, W. M. Czarnecki, M. Mathieu, A. Dudzik, J. Chung, D. H. Choi, R. Powell, T. Ewalds, P. Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019.   \n[65] T. Wang and P. Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. In International Conference on Machine Learning, pages 9929–9939. PMLR, 2020.   \n[66] D. Warde-Farley, T. V. de Wiele, T. D. Kulkarni, C. Ionescu, S. Hansen, and V. Mnih. Unsupervised control through non-parametric discriminative rewards. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   \n[67] D. Yarats, R. Fergus, A. Lazaric, and L. Pinto. Reinforcement learning with prototypical representations. arXiv preprint arXiv:2102.11271, 2021.   \n[68] R. Zhao, Y. Gao, P. Abbeel, V. Tresp, and W. Xu. Mutual information state intrinsic control. arXiv preprint arXiv:2103.08107, 2021.   \n[69] B. D. Ziebart, A. L. Maas, J. A. Bagnell, and A. K. Dey. Maximum entropy inverse reinforcement learning. In Aaai, volume 8, pages 1433–1438. Chicago, IL, USA, 2008. ",
+        "bbox": [
+            178,
+            837,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            63,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            78,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            60,
+            828,
+            922
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            826,
+            154
+        ],
+        "page_idx": 14
+    }
+]

parse/train/iklDP-v1sgi/iklDP-v1sgi.md

@@ -0,0 +1,596 @@
+# Meta Reinforcement Learning for Fast Adaptation of Hierarchical Policies
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Hierarchical methods have the potential to allow reinforcement learning to scale to   
+2 larger environments. Decomposing a task into transferable components, however,   
+3 remains a challenging problem. In this paper, we propose a meta-learning approach   
+4 for learning such a decomposition within the options framework. We formulate   
+5 the objective as a bi-level optimization problem in which sub-policies and their   
+6 terminations should facilitate fast learning on a family of tasks. Once such a set   
+7 of options is obtained, it can then be used in new tasks where only the sequencing   
+8 of options needs to be chosen. Our formalism tends to result in options where   
+9 fewer decisions are needed to solve such new tasks. Experimentally, we show that   
+10 our method is able to learn transferable components which accelerate learning and   
+11 performs better than existing methods developed for this setting in the challenging   
+12 ant maze locomotion task.
+
+# 13 1 Introduction
+
+14 Current state of the art model-free reinforcement learning methods were successfully applied to   
+15 many challenging tasks [33, 41]. However, one of the main drawbacks of these methods is their   
+16 data-inefficiency and inability to generalize to other related tasks [12]. It is often impossible to use   
+17 the agent trained on one task to solve another related task [53] or even to use it as a starting point for   
+18 training because trained models become increasingly exploitative and thus are unable to explore in a   
+19 new task. In such cases, we have to gather new data and train a new model which is time-consuming.   
+20 One way to mitigate this problem is by learning a policy with reusable modules which can be used in   
+21 multiple tasks. For example, if we assume that related tasks contain shared sub-tasks (i.e. tasks come   
+22 from the same family or have hierarchical structure), we can speed up the adaptation to new tasks by   
+23 learning sub-policies that solve these sub-tasks. This is because solutions to new tasks can be created   
+24 by combining known solutions to sub-tasks during adaptation. The idea of learning reusable skills in   
+25 multiple environments, which dates back to at least 1995 [48], was thoroughly explored within the   
+26 options framework [17, 24, 25, 29, 36, 46].   
+27 In this framework, a policy is composed of options (modules that encapsulate sub-policies), and   
+28 a high-level policy that chooses among them. Options have their own termination function, and a   
+29 new option is only initiated when the earlier option terminates. Therefore, options define temporally   
+30 extended behaviors that can form solutions to sub-tasks. Despite extensive research in this area, there   
+31 is not yet a consensus on answers to many important questions about options: What are good options?   
+32 How can we find them? When should a termination occur? How many options should one use? In   
+33 this work our aim will be to find options that allow for fast adaptation to tasks from the same family.   
+34 We use this single principle to address all of these questions except for the number of options which   
+35 we consider a hyperparameter.   
+36 Learning high-level policy, sub-policies and terminations at the same time is a challenging task.   
+37 Recent prior work on options proposed a way to learn both, including the terminations, in an end   
+38 to end manner with policy gradient methods [4, 44]. However, despite achieving good performance   
+39 in single-task settings, these methods often produce options which may not be useful for transfer   
+40 [21, 22]. This is because such options are not explicitly trained for multi-task setting and can often   
+41 terminate too often or not at all [21, 22].   
+42 To overcome this issue, Frans et al. [17] proposed to use such method in a multi-task setting with   
+43 options that have predefined length and are optimized for performance after adaptation of the high  
+44 level policy. Although options that terminate after certain amount of steps simplify the problem   
+45 and work well in some settings [17, 25], manually setting this important hyperparameter requires   
+46 prior knowledge and might not work in cases where options need to have different lengths [23]. For   
+47 example, task where this approach would not be preferable could be driving because some driving   
+48 sub-tasks, such as driving on a highway, are much longer than others, such as driving out from one   
+49 intersection to another in a city. Consequently, capturing the length of both sub-tasks with a single   
+50 hyperparameter [17] or range of hyperparameters [25] can become difficult or even impossible. In   
+51 such cases, learned terminations are preferable.   
+52 In this paper, we propose a method for learning options that allows for fast adaptation to multiple tasks.   
+53 We formalize this notion using recent ideas from gradient based meta-learning [14]. Rather than using   
+54 options with fixed length [17], our algorithm learns both sub-policies and when to terminate options   
+55 using a single meta-learning objective. We hypothesize that this objective implicitly encourages   
+56 options to terminate in a way that yields reusable components. In our experiments, we demonstrate   
+57 the benefits of our approach in a simple Taxi domain as well as in a complex Mujoco [49] Ant Maze   
+58 domain [17].
+
+# 2 Related Work
+
+Since our work builds on insights from both hierarchical reinforcement learning and meta-learning, we present related work in both domains separately, in subsections 2.1 and 2.2 respectively.
+
+# 2.1 Hierarchical Reinforcement Learning
+
+63 One of the aims of hierarchical reinforcement learning is to decompose a complex task or policy into   
+64 simpler units. Popular approaches include learning a diverse set of skills [11] or utilizing the idea of   
+65 Feudal Reinforcement Learning [7, 34, 50]. Another large collection of related work instead relies on   
+66 the options framework [46].   
+67 Some works on options rely on so-called bottleneck states that can be used as sub-goals [30, 31, 35]   
+68 whereas others use spectral clustering to create options [28]. These approaches usually require prior   
+69 knowledge about the environment which restricts their applicability. Different from aforementioned   
+70 methods, end-to-end methods such as the ones which rely on the Option-Critic architecture [4, 39] are   
+71 applicable in more general settings. However, these policy gradient methods can be less efficient than   
+72 concurrently introduced inference based end-to-end methods [6, 16, 44] because they only update the   
+73 option that generated the action whereas inference based methods update options according to their   
+74 responsibilities for each action.   
+75 A common problem with end-to-end methods that learn terminations in a single-task setting is   
+76 option collapse [4]. This causes options to terminate after every action or to never terminate. In   
+77 such cases the learning of terminations can be facilitated by augmenting the objective with entropy   
+78 regularization [44] or deliberation cost [21], regularizing towards a termination prior [23], or by   
+79 optimizing different objective that encourages appropriate terminations [22]. As an alternative, one   
+80 can also use time-based terminations with fixed [17] or randomized length [25].
+
+# 2.2 Meta-Reinforcement Learning
+
+82 Meta-reinforcement learning is concerned with producing models which are able to adapt to novel   
+83 tasks quickly. This sub-field includes a broad range of work such as unsupervised methods [11, 19],   
+84 methods that rely on latent variables [20, 38] or methods that learn the update rule of a policy   
+85 [10, 32, 51].   
+86 In contrast with the latter, the recent gradient-based method Model-Agnostic Meta-Learning   
+87 (MAML) [14] assumes that policy parameters are updated with gradient descent and instead aims to   
+88 learn initial parameter values. MAML was extended in followup works that only trained a part of the   
+89 network [37, 54] or showed benefits of different architectural choices such as per-parameter learning   
+90 rates [3, 26]. Several works also focused on MAML in a reinforcement learning setting [2, 27, 45].   
+91 In particular, Al-Shedivat et al. [2] and Stadie et al. [45] pointed out a difference between theory and   
+92 practical implementation of MAML in automatic differentiation frameworks. This issue was further   
+93 discussed and resolved in followup works [13, 15, 40].   
+94 Lastly, there exist methods which do not employ the techniques mentioned above and instead rely   
+95 on the options framework [5, 17, 23–25, 29, 36, 52] or task-specific policies [47]. These approaches   
+96 often make different assumptions about the tasks and settings in which they are applied. Some require   
+97 policies that solve each environment [36] whereas others need environment ID [23, 29] or cumulants   
+98 that properly represents task dynamics [5]. Closest to our work are Meta Learning Shared Hierarchies   
+99 (MLSH) [17] and Adaptive Skills Adaptive Partitions (ASAP) [29]. ASAP uses a policy gradient   
+100 method to optimize immediate performance on multiple tasks with known environment ID but does   
+101 not use neural networks and does not learn terminations. On the other hand, MLSH uses a hierarchical   
+102 structure with predefined options length and a problem setting with unknown environment ID. It   
+103 optimizes for post-adaptation performance by using two alternating phases that either only update   
+104 high-level policy or both high-level policy and sub-policies simultaneously. This approach does not   
+105 use the information from the intermediate adaptation steps when calculating the gradient which can   
+106 negatively affect its accuracy. Additionally, options with fixed length may be difficult to use in some   
+107 settings as we’ve described in Section 1.
+
+# 108 3 Background and Notation
+
+In this section, we will first cover the fundamentals of reinforcement learning, and then focus on the options framework and gradient-based meta-learning.
+
+# 111 3.1 Reinforcement Learning and the Options Framework
+
+112 We will consider environments which are episodic Markov decision processes (MDPs). An MDP   
+113 $\mathcal { M }$ is a tuple $\langle S , A , p _ { 0 } , P , R , \gamma \rangle$ with $S$ being a set of states, $A$ a set of actions, $p _ { 0 } ( s _ { 0 } )$ a probability   
+114 distribution of initial states, $P ( \pmb { s } ^ { \prime } | \pmb { s } , \pmb { a } )$ a transition probability function, $R ( s , a )$ a reward function   
+115 and $\gamma$ a discount factor.   
+116 An agent with a stochastic policy $\pi$ interacts with an environment $\mathcal { M }$ in the following way. At   
+117 every timestep $t$ , the agent receives a state of the environment $\textbf { \textit { s } } _ { t } ~ \in ~ \textbf { \textit { S } }$ and selects an action   
+118 $\mathbf { \Sigma } _ { \mathbf { \Phi } _ { t } } ~ \in ~ \mathbf { \Sigma } _ { A }$ according to conditional distribution $\pi ( \mathbf { \boldsymbol { a } } _ { t } | \mathbf { \boldsymbol { s } } _ { t } )$ . Depending on the current state and the   
+119 action performed, the environment provides the agent with a new state $s _ { t + 1 } \sim P ( s _ { t + 1 } | s _ { t } , \mathbf { a } _ { t } )$ and   
+120 a scalar reward $r _ { t } = R ( s _ { t } , { \pmb a } _ { t } )$ . This process is repeated until a so-called terminal state is reached.   
+121 We define a trajectory $\tau$ as an ordered sequence of all states actions and rewards in a single episode   
+122 $\tau = ( s _ { 0 } , { \pmb a } _ { 0 } , r _ { 0 } , . . . , s _ { T } ) .$ . Similarly, the history at timestep $t$ consists of all states and actions preceding   
+123 $\mathbf { } \mathbf { a } _ { t }$ , $\pmb { h } _ { t } = ( \pmb { s } _ { 0 } , \pmb { a } _ { 0 } , . . . , \pmb { s } _ { t } )$ . The state value function is defined as $V _ { \pi } ( \pmb { s } ) = \mathbb { E } _ { \pi } \left[ G _ { t } | \pmb { s } _ { t } = \pmb { s } \right]$ where the   
+124 discounted return at timestep $t$ is defined as $\begin{array} { r } { G _ { t } ( \tau ) = \sum _ { t ^ { \prime } = t } ^ { T } \gamma ^ { ( t - t ^ { \prime } ) } r _ { t ^ { \prime } } } \end{array}$ .   
+125 The agent’s objective is to maximize the expected discounted return $J ~ = ~ \mathbb { E } _ { p ( \tau \mid \theta ) } \left[ G _ { 0 } ( \tau ) \right]$ .   
+126 127 $\begin{array} { r } { \nabla _ { \theta } J \approx \mathbb { E } _ { p ( \tau | \theta ) } [ \sum _ { t = 0 } ^ { T } \nabla _ { \theta } \log \pi _ { \theta } ( \mathbf { a } _ { t } | \mathbf { s } _ { t } ) \mathbf { } \mathbf { } \mathbf { } A _ { t } ] } \end{array}$ gradient descent by estimating thusing Monte Carlo sampling, where $A _ { t }$ policy gradientis an advantage   
+128 estimator such as the generalized advantage estimator $A _ { t } ^ { G A E }$ [42].   
+129 The options framework is a framework for temporal abstraction that consists of options   
+130 $\omega = \langle \bar { \mathcal { T } } ^ { \omega } , \pi ^ { \omega } , \xi ^ { \omega } \rangle$ and a policy over options $\pi ^ { \Omega } ( \omega | s )$ . Each option $\omega$ consists of an initiation set, a   
+131 sub-policy and a termination function. The initiation set ${ \mathcal { T } } ^ { \omega }$ is a set of states in which an option can   
+132 be selected (initiated) and in our case it is the whole state space $( \mathbb { Z } ^ { \omega } = S$ ). A sub-policy $\bar { { \boldsymbol { \pi } } } ^ { \omega } ( a | s )$ ,   
+133 also called low-level policy, is a regular policy that acts in the environment. Lastly, the termination   
+134 condition $\xi ^ { \omega } ( s )$ is a function that outputs the probability of termination for the option in a given state.   
+136 Model-Agnostic Meta-Learning (MAML) [14] is a meta-learning technique that trains a model for   
+137 maximum post-adaptation performance on a distribution of tasks. The adaptation consists of one or   
+138 several inner gradient updates. If we consider an estimator $f _ { \theta }$ with parameters $\theta$ and a task-specific   
+139 loss $\mathcal { L } _ { \mathcal { M } _ { i } }$ , a supervised learning objective with a single inner update can be formalized as shown in   
+140 Equation 1. In order to optimize this objective one only needs to take a gradient of this expression.   
+141 This can be easily achieved with automatic differentiation frameworks by creating a backpropagation   
+142 graph for the gradient.
+
+$$
+\operatorname* { m i n } _ { \theta } \mathbb { E } _ { \mathcal { M } } \left[ \mathcal { L } _ { \mathcal { M } _ { i } } ( f _ { \theta ^ { \prime } } ) \right] = \operatorname* { m i n } _ { \theta } \sum _ { \mathcal { M } _ { i } \sim p ( \mathcal { M } ) } \mathcal { L } _ { \mathcal { M } _ { i } } ( f _ { \theta - \alpha \nabla _ { \theta } \mathcal { L } _ { \mathcal { M } _ { i } } ( f _ { \theta } ) } )
+$$
+
+143 One can similarly use this approach with a reinforcement learning objective. However, the implemen  
+144 tation with an automatic differentiation framework differs because a simple backpropagation through   
+145 the computation graph of the gradient produces biased gradients [2, 45]. This is due to an additional   
+146 dependency of the sampling distribution on parameters that is not present in the supervised learning   
+147 objective. To produce correct higher order gradients with automatic differentiation frameworks in   
+148 a reinforcement learning setting, one can use the objective in Equation 3 as proposed by Farquhar   
+149 et al. [13]. This objective utilizes the DiCE operator $\boxdot$ [15] which can be implemented according   
+150 to Equation 2 where $\bot ( x )$ is a stop gradient operator that evaluates to $x$ but returns a zero gradient   
+151 when differentiated.
+
+$$
+\begin{array} { r } { \Xi ( \mathbf { a } _ { t } ) = \exp \left[ \log \pi _ { \theta } ( \mathbf { a } _ { t } | s _ { t } ) - \perp ( \log \pi _ { \theta } ( \mathbf { a } _ { t } | s _ { t } ) ) \right] , \quad \nabla _ { \theta } \mathbb { E } _ { \tau \sim p ( \tau | \theta ) } \left[ G _ { 0 } ^ { M _ { i } } ( \tau ) \right] \approx \nabla _ { \theta } J _ { \bigstar } \pi _ { \star } ( \tau ) . } \end{array}
+$$
+
+152
+
+$$
+\nabla _ { \theta } J _ { \bigstar \bigstar } = \mathbb { E } _ { \tau \sim p ( \tau | \theta ) } \left[ \sum _ { t = 0 } ^ { T } \nabla _ { \theta } \bigg ( \prod _ { t ^ { \prime } = 0 } ^ { t } \Xi ( a _ { t ^ { \prime } } ) \lambda ^ { t - t ^ { \prime } } A _ { t } ^ { G A E } - \prod _ { t ^ { \prime } = 0 } ^ { t - 1 } \Xi ( a _ { t ^ { \prime } } ) \lambda ^ { t - t ^ { \prime } } A _ { t } ^ { G A E } \bigg ) \right] .
+$$
+
+# 153 4 Fast Adaptation of Modular Policies
+
+154 Much of the extensive research in the options framework has focused on an intuition of options   
+155 capturing useful sub-tasks [4, 17, 36, 46]. However, there is no consensus about capturing this   
+156 intuition in an objective function or the best way to find such options. We propose a conceptually   
+157 simple objective: a good set of options allows quick adaptation to many novel tasks. This can   
+158 be formulated using the MAML framework [14], where we consider a setting in which there is a   
+159 distribution of tasks $p ( \mathcal { M } )$ with similar (hierarchical) structure but different reward or transition   
+160 functions. Our goal is then to maximize the expected performance after $L$ adaptation steps of the   
+161 hierarchical policy parametrized by $\theta$ :
+
+$$
+\operatorname* { m a x } _ { \theta } \sum _ { M _ { i } \sim p ( \mathcal { M } ) } \mathbb { E } _ { \tau ^ { L } \sim p ( \tau ^ { L } \mid \theta ^ { L } ) } \left[ G _ { 0 } ^ { M _ { i } } ( \tau ^ { L } ) \right] , \quad \theta ^ { j + 1 } = \theta ^ { j } + \alpha _ { i n } \nabla _ { \theta ^ { j } } \mathbb { E } _ { \tau ^ { j } \sim p ( \tau ^ { j } \mid \theta ^ { j } ) } \left[ G _ { 0 } ^ { M _ { i } } ( \tau ^ { j } ) \right] .
+$$
+
+162 Using conventional MAML means adapting a large number of parameters which can be disadvanta  
+163 geous, as was demonstrated by Zintgraf et al. [54] and Antoniou et al. [3]. By reducing the number of   
+164 parameters that are tuned during the adaptation phase, one can reduce the complexity of the problem   
+165 during test time at the cost of a less expressive policy. We thus split the parameters into an inner group   
+166 $\theta _ { \mathrm { i n } }$ and an outer group $\theta _ { \mathrm { o u t } }$ where inner parameters are updated during the adaptation step and outer   
+167 parameters are optimized in the outer objective. Note that when using such split, the initialization   
+168 values of inner parameters may also be meta-learned [54]. We experimented with both versions and   
+169 observed that fixed initialization values performed better. Similarly, the per-parameter inner learning   
+170 rate $\alpha _ { i n }$ [3, 26] can also be meta-learned to allow for more complex inner updates. We used this   
+171 approach in a setting with more complex environment.   
+172 Our option model has three sets of parameters: those of the high-level policy network $\theta _ { \Omega }$ , sub-policy   
+173 networks $\theta _ { \omega }$ and termination networks $\theta _ { \xi }$ . We now divide these over the inner and outer parameter   
+174 group. Since we assume that tasks with common sub-problems can be solved using identical options,   
+175 we consider the sub-policy and termination function parameters as outer parameters. On the other   
+176 hand, since in each task the decision of the high-level policy to choose options would be different,   
+177 its parameters constitute the inner group. By keeping sub-policies fixed during the adaptation and
+
+initialize θΩ, θξ , θω , αin , αout   
+set $\theta _ { i n } = \theta _ { \Omega }$   
+set $\theta _ { o u t } = \{ \theta _ { \xi } , \theta _ { \omega } \}$   
+repeat Set gradient of outer parameters $\mathbf { \nabla } _ { \mathbf { \theta } _ { \partial u t } } \mathbf { \Psi } = 0$ for $n = 1$ to $N$ do set $\theta _ { i n } ^ { \prime } = \theta _ { i n }$ sample a task $\mathcal { M } \sim p ( \mathcal { M } )$ for $l = 1$ to $L + 1$ do sample $k$ episodes $\tau _ { 1 : k }$ on $\mathcal { M }$ using $\pi _ { \{ \theta _ { i n } ^ { \prime } , \theta _ { o u t } \} }$ fit a baseline Vκ using data from τ1:k compute $A _ { t } ^ { G A \ddot { E } }$ for all $\tau _ { 1 : k }$ compute $\log \pi ( \boldsymbol { a } _ { t } | \boldsymbol { h } _ { t } ) = \mathbb { E } _ { \omega | \boldsymbol { h } _ { t } } [ \pi ^ { \omega } ( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } ) ]$ compute $J _ { \bigodot }$ with $A _ { t } ^ { G A E } , \log \pi ( { \pmb a } _ { t } | { \pmb h } _ { t } )$ (Eqs. 2, 3) if $l < L + \overline { { 1 } }$ then $\theta _ { i n } ^ { \prime } = \theta _ { i n } ^ { \prime } + \alpha _ { i n } \nabla _ { \theta _ { i n } ^ { \prime } } J _ { \overline { { \mathbf { \bullet } } } }$ else $\begin{array} { c } { { { \pmb g } _ { \theta _ { o u t } } = { \pmb g } _ { \theta _ { o u t } } + \nabla _ { \theta _ { o u t } } J _ { \pmb { \left[ \pmb { \hat { \backprime } } \right] } } } } \\ { { \theta _ { o u t } = \theta _ { o u t } + \alpha _ { o u t } \frac { 1 } { N } { \pmb g } _ { \theta _ { o u t } } } } \end{array}$   
+until convergence
+
+178 restricting the update to the high-level policy, we optimize for options that can be used to solve   
+179 multiple tasks, thereby allowing the overall policy to adapt quickly with the change of high-level   
+180 policy. This also allows for an expressive policy which can capture different behaviors and reduces   
+181 the number of parameters and decisions an agent needs to learn and make during test time.   
+182 Formally, our final objective can be expressed as Equation 5 with the inner update given by Equation   
+183 6. The objective is similar to the one used in MLSH [17] with some key differences. Firstly, by   
+184 backpropagating through the update step we are able to capture additional information from the   
+185 adaptation steps in the gradient and secondly, our objective includes the optimization of termination   
+186 parameters and thus allows for options with different lengths.
+
+$$
+\begin{array} { r l } & { \displaystyle \operatorname* { m a x } _ { \theta _ { \omega } , \theta _ { \xi } } \sum _ { { \mathcal M } _ { i } \sim p ( { \mathcal M } ) } { \mathbb E } _ { \tau \sim p ( \tau \mid \{ \theta _ { \omega } , \theta _ { \xi } , \theta _ { \Omega } ^ { L } \} ) } \left[ G _ { 0 } ^ { { \mathcal M } _ { i } } ( \tau ) \right] } \\ & { \displaystyle \theta _ { \Omega } ^ { j + 1 } = \theta _ { \Omega } ^ { j } + \alpha _ { i n } \nabla _ { \theta _ { \Omega } ^ { j } } { \mathbb E } _ { \tau \sim p ( \tau \mid \{ \theta _ { \omega } , \theta _ { \xi } , \theta _ { \Omega } ^ { j } \} ) } \left[ G _ { 0 } ^ { { \mathcal M } _ { i } } ( \tau ) \right] . } \end{array}
+$$
+
+# 187 4.1 Algorithm
+
+188 Written in its general form the objective leaves some freedom with regard to which policy gradient   
+189 algorithm is used for gradient calculation. In our work we use the Inferred Option Policy Gradient   
+190 (IOPG) [44] because it updates all options at the same time based on their responsibilities, i.e., the   
+191 probability that the option was active given the history $\pmb { h } _ { t }$ of states and actions so far. This can lead to   
+192 better data-efficiency when compared to other methods that only update a single option at a time but   
+193 comes at the cost of increased computation time. Another important design choice is the state value   
+194 function estimator. In the MAML RL setting the policy constantly changes in every inner update. It is   
+195 thus difficult to use past trajectories for fitting the value function. We therefore use a linear time-state   
+196 dependent baseline [9] which works better than more complex baselines with little data and was also   
+197 used in the original MAML implementation.   
+198 The resulting algorithm for Fast Adaptation of Modular Policies (FAMP) is outlined in Algorithm 1.   
+199 Note that in order to use IOPG with DiCE we replace $\pi ( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } )$ with $\pi ( \mathbf { \boldsymbol { a } } _ { t } | \mathbf { \boldsymbol { h } } _ { t } )$ in Equation 2. An   
+200 intuition about why this is possible comes from the fact that we can easily formulate a new MDP   
+201 $\tilde { \mathcal { M } }$ in which states $\tilde { s } _ { t }$ are histories $\pmb { h } _ { t }$ of the original MDP without otherwise altering the dynamics.   
+202 After $L$ inner updates, the gradient of the objective with respect to the outer parameters is calculated.   
+203 In principle, we would like to optimize for performance after a moderate number of gradient updates   
+204 $L$ such as 10 or 20. However, with more inner updates the resulting gradient of the objective becomes   
+205 noisier due to the usage of Monte Carlo estimate in each inner update. Furthermore, the time   
+206 complexity of gradient computation and sample complexity both scale linearly with the number of   
+207 inner updates. In practice we found a range from 2 to 4 update steps to be acceptable. An important   
+208 benefit of gradient-based meta-learning is that even though the model is optimized for performance   
+209 after $L$ adaptation steps, it can still be improved after $L$ updates by performing more steps of gradient   
+210 descent.
+
+![](images/11b10b77111fd2ba86e496f0980568cdb89d2062317dcefd5b981c41fe2f00f5.jpg)  
+Figure 1: Left: Map of a taxi environment with special states and an example task. Middle and Right: Visualization of the option usage in this task. Middle part shows states without passenger on board. Right part shows states with passenger. Arrows represent directional actions, pick-up/drop-off is shown as a square. Each action is colored according to the active option.
+
+# 5 Experiments
+
+In this section, we empirically evaluate our method and show its benefits when applied to randomly selected tasks within and outside of the training distribution.
+
+# 214 5.1 Taxi
+
+215   
+216   
+217   
+218   
+219   
+220   
+221   
+222   
+223   
+224   
+225   
+226   
+227   
+228
+
+In the first set of experiments we use a modified Taxi environment1 [8] displayed in Figure 1. An agent acts as a taxi driver who starts in one of the special (colored) locations. The goal of the driver is then to drive a passenger from one of the special locations to his destination. The task family consists of 60 different tasks with different combination of start, goal and passenger positions. These are always initialized in special states. In 12 out of 60 easier configurations the passenger starts the episode in the car. The only restriction on start, goal and passenger positions in all cases is that passenger’s destination must not be the same as his initial position. Each task is an MDP in which the agent can use 4 directional actions and two special actions: pick-up/drop-off and no-op. The state space is represented as a one-hot vector with 72 entries for every combination of possible taxi location and passenger being on board. Thus the agent does not have any information about the location of the passenger or goal state. Therefore, in order to facilitate fast adaptation to the (unobservable) passenger and goal locations, the agent must acquire options that can serve as building blocks for exploration. The reward is 2 for reaching the goal and $- 0 . 1$ per step otherwise. To speed up training in the early phases, we terminate the episode if it takes longer than 1500 timesteps.
+
+229   
+230   
+231   
+232   
+233   
+234   
+235   
+236   
+237   
+238   
+23
+
+In this experiment, we use tabular representations implemented as a combination of linear layer and non-linearity for the policy over options, terminations and sub-policies such that each one-hot state has its own set of parameters. We use 48 training tasks to train sub-policies and terminations with our algorithm. Learned terminations and sub-policies are then kept fixed during test time and only the policy over options is updated. Performance is then compared on the remaining 12 test tasks (selected to use combinations of special locations with similar frequency) to MLSH and two baselines. We chose MLSH because it is a closest hierarchical method designed for our setting in which there is no extra information about the environment available. This is in contrast with many other hierarchical [5, 23, 29] and non-hierarchical [38, 47] meta-reinforcement learning methods which utilize extra information such as the ID of a sampled environment.
+
+9 Similarly to our method, MLSH is trained on all training tasks and evaluated with fixed sub-policies.   
+0 The multi-task baseline is an IOPG algorithm that learns a shared policy (including high-level policy)   
+241 by optimizing average return over tasks rather than the meta-learning objective in Equations 5 and   
+242 6. After the training, it only adapt its high-level policy on test tasks. We expect this baseline to   
+243 perform poorly in the long run because it does not optimize for post-update performance. Lastly,   
+244 the single-task baseline is an IOPG algorithm that learns the test tasks from scratch without any   
+245 pre-training. Therefore, since it does not need to generalize to many tasks and has a policy with   
+246 enough capacity, we expect that it should eventually outperform other methods after sufficiently   
+247 long training. However, meta-learned policy with desirable options should find good solution much   
+248 quicker. To make the single-task baseline as strong as possible, we set its learning rate to the highest   
+249 value that was able to solve all tasks reliably.
+
+![](images/6cbe98a638d7064b46eaf89975adaf7d9fc316d9e522d9fb12da6bd7130c4124.jpg)  
+Figure 2: Left: Average performance of different algorithms on taxi environment test tasks. Plot shows mean and standard deviation over 5 seeds. Right: Average performance of our method with different hyperparameter values on taxi environments test tasks. Plot shows median and interquartile range over 5 seeds.
+
+# 250 Results
+
+51 As shown in Figure 2, our method is able to outperform both MLSH and the multi-task baseline   
+252 reaching the final performance of $- 0 . 3 1 5$ . Furthermore, it also outperforms all other algorithms   
+253 in terms of adaptation speed. We additionally checked whether the single-task baseline eventually   
+254 overtakes FAMP and found that after more than 200 episodes, its performance stabilizes at a final   
+255 discounted return value of $- 0 . 2 8 4$ . This demonstrates that FAMP can learn sub-policies and termi  
+256 nations that allow for fast adaptation in similar unseen environments at the cost of slightly lower   
+257 asymptotic performance. An example trajectory that was produced by the agent in one of the hardest   
+258 test tasks is displayed in Figure 1. In this task, the agent is able to combine three options to form an   
+259 optimal solution. Plots with meta-training curves and learned options are included in Appendix C.   
+260 In Figure 2 (right), we show how the performance varies with changes to important hyperparameters,   
+261 namely, the number of options and adaptation steps. We observe that decreasing the number of   
+262 adaptation steps during training to one leads to a clear drop in performance. This can be attributed to   
+263 the policy not being able to switch from exploratory to exploitatory behavior in a single inner update   
+264 as well as the smaller amount of data observed before each outer update.   
+265 Unlike the number of adaptation steps, the number of options does not seem to affect the performance   
+266 too much. The only noticeable exception is lower performance when using only 2 options. This   
+267 exception can be explained by noticing that in some states one needs to perform 3 different actions   
+268 to represent all optimal paths. As an example, consider the state two squares above the blue special   
+269 state in Figure 1. To reach the blue state in the minimum number of steps the agent needs to use the   
+270 down action. Similarly, to go from the blue state to the red or yellow one it needs to use up and right   
+271 respectively. Thus the agent cannot represent the optimal policies with only 2 options. Interestingly,   
+272 even in this case, the agent is still able to separate trajectories in such a way that it can reach all goals   
+273 albeit with slightly worse performance.   
+274 This outcome demonstrates another benefit of learned option lengths as the optimal option length   
+275 does not only depend on tasks and their difficulty but also on the number of options that are available.   
+276 To illustrate this, consider an extreme case where there are as many options as tasks. In this case, it   
+277 would be sensible to have solution to a different task in each option and not terminate at all because   
+278 each task would be solved with only one high-level action. However, as the number of available   
+279 options decreases, sharing options between tasks becomes necessary and terminations should start to
+
+Table 1: Percentage of terminations in trajectories obtained from adapted policies averaged over 5 seeds. Standard deviations are in $1 \%$ range.
+
+<table><tr><td rowspan=1 colspan=1>Number of options</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>16</td></tr><tr><td rowspan=1 colspan=1>Avg. terminations in traj</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>63%</td><td rowspan=1 colspan=1>57%</td><td rowspan=1 colspan=1>55%</td><td rowspan=1 colspan=1>44%</td><td rowspan=1 colspan=1>28%</td></tr></table>
+
+![](images/2be204a1d222a55fbe76bab216be6e5236945ba7b5f170a1f816e2c217132a2a.jpg)  
+Figure 3: Ant maze tasks. The agent needs to control a simulated 4-legged ant-like robot and move it towards the green square.
+
+280 occur to allow for all tasks to be solved. Moreover, if the number of options is decreased even further,   
+281 there may not be enough to options to capture the optimal behavior for all tasks. Consequently, it   
+282 becomes even more difficult to choose the appropriate option length a priori since it can depend on   
+283 the number of available options. To confirm this intuition, we ran a followup experiment with longer   
+284 time horizon in the taxi environment. While the trajectories produced by adapted policies had similar   
+285 length, relative number of terminations decreased with the increase in the number of options as shown   
+286 in Table 1.
+
+# 287 5.2 Ant Maze
+
+288 In our second experiment, we demonstrate the applicability of our method to more complex environ  
+289 ments. We use the family of ant maze tasks introduced by Frans et al. [17] shown in Figure 3. This   
+290 allows us to reproduce the results of MLSH as closely as possible by mirroring the setting used in   
+291 the original paper. In addition to MLSH, we also compare to $\mathtt { R L } ^ { 2 }$ , a non-hierarchical meta-learning   
+292 algorithm designed for fast-adaptation and Proximal Policy Optimization (PPO) [43], which serves   
+293 as a strong single-task baseline.   
+294 In each task the agent needs to move a simulated 4-legged ant-like robot through a small maze towards   
+295 the goal. Both state space and action space are continuous with 29 and 8 dimensions respectively   
+296 and each episode lasts 1000 timesteps. States do not contain any information about the maze layout   
+297 or the location of the goal. The original implementation also resets the orientation of the ant every   
+298 200 steps. However, we removed these resets because they made the MDP partially observable,   
+299 introduced discontinuities and were not realistic for the robotics scenario they are supposed to imitate.   
+300 Results of experiments with the original implementation are similar to the ones we present. They can   
+301 be found in Appendix C along with meta-training plots.   
+302 Both FAMP and MLSH use the same architecture with two hidden layers of 64 nodes to represent the   
+303 high-level policy, sub-policies and terminations (only applies to FAMP). We used existing repositories   
+304 for the implementation of $\mathtt { R L } ^ { 2 }$ [18] and PPO [1]. Hyperparameter values can be found in Appendix   
+305 B. During the training phase, sub-policies (and terminations) of both hierarchical algorithms were   
+306 trained on all tasks until the return averaged over all environments stopped improving. In the test   
+307 phase all parameters except for the policy over options were frozen. Similarly, $\hat { { \mathrm { R L } } ^ { 2 } }$ was pre-trained   
+308 on all tasks and subsequently evaluated while PPO was trained from scratch.   
+309 The comparison of the performance and speed of adaptation can be seen in Figure 4 (left). Our   
+310 method achieves superior performance reaching an average return of 1330. We also observed a   
+311 similar trend across individual environments. Plots of these comparisons are available in Appendix C.   
+312 While the zero-shot performance of $\mathtt { R L } ^ { 2 }$ is slightly better than FAMP, it often struggles to further   
+313 adapt to specific tasks and quickly gets outperformed by both hierarchical methods. This is likely be   
+314 due to the objective that optimizes average return over all training episodes and not post-adaptation   
+315 performance directly. Lastly, PPO continuously improves but its performance does not come close to   
+316 the meta-learning algorithms. After about 1000 episodes it reaches the performance of MLSH and if   
+317 ran sufficiently long , we would expect that it would eventually catch up to FAMP.   
+318 We visualize the option usage of FAMP on two example tasks in Figure 4 (right). After the high-level   
+319 policy is fine-tuned, we use the $x$ and $y$ positions of the ant in 3 sampled trajectories to highlight   
+320 which option is active at each part of the state space. Although we only take 2 out of 29 dimensions   
+321 into account, we are still able to get useful insight about the learned option structure. In the task that   
+322 is depicted in the left part of the plot, the agent uses the blue option before switching to cyan in the   
+323 middle and finishing with a combination of blue and purple. On the other hand, in the right task, the   
+324 agent uses a combination of blue and purple to move down instead of to the right. This shows that the   
+325 agent learned a useful abstraction that allows it to perform two different useful behaviors in similar   
+326 parts of the state space by using terminations and different options.
+
+![](images/9bef7bf587ff121b72310db790213d994ef96fa9a115b07729a272de2bdff666.jpg)  
+Figure 4: Left: Average performance of algorithms on ant maze environments tasks. Plot shows mean and standard deviation over 3 seeds. Right: Option usage visualization on ant maze tasks. Both plots were created using positions of the ant during 3 trajectories. Each of the 3 options is represented by a different color.
+
+# 327 6 Discussion and Future Work
+
+328 In this work, our aim was to learn both sub-policies and terminations of options by using a single   
+329 simple principle: options should accelerate adaptation in many tasks. We proposed a method for   
+330 learning hierarchical policies that combines the options framework with gradient-based meta-learning   
+331 and explicitly optimizes for performance after several adaptation steps. In our experiments, we   
+332 have demonstrated the benefits of our approach in quickly learning previously unseen test tasks.   
+333 Furthermore, we have shown that the proposed method outperforms the closest hierarchical and   
+334 non-hierarchical meta-reinforcement learning methods designed for similar setting in a challenging   
+335 multi-task learning scenario.   
+336 The computation limitations of our method are mostly connected to the calculation of responsibilities   
+337 in IOPG. In this calculation, many sequential matrix multiplications are required both in the forward   
+338 and backward pass. The compute time for each update is thus dependent on the trajectory length   
+339 because these calculations cannot be done in parallel. One direction for future work could thus be   
+340 alleviating this limitation.   
+341 Our objective does not explicitly constrain the number of terminations as long as they lead to fast   
+342 adaptation. Thus, there are many combinations of options with different lengths which can lead to   
+343 good performance on all tasks, which do not always correspond to intuitive decompositions. One   
+344 possible cause of spurious terminations lies in the continuous state space used in some tasks. When   
+345 neural networks are used to represent termination functions, they learn to generalize to nearby states.   
+346 In tasks such as the ant maze, the agent will visit many states in the same neighborhood and might   
+347 thus terminate options several times in quick succession. A promising topic for future investigation is   
+348 whether this problem could be alleviated by using terminations that also depend on the state in which   
+349 the option was initiated.
+
+# References
+
+[1] Joshua Achiam. Spinning Up in Deep Reinforcement Learning. 2018. [2] Maruan Al-Shedivat, Trapit Bansal, Yura Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel. Continuous Adaptation via Meta-Learning in Nonstationary and Competitive Environments. In International Conference on Learning Representations, 2018. [3] Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your MAML. In International Conference on Learning Representations, 2019.   
+[4] Pierre-Luc Bacon, Jean Harb, and Doina Precup. The Option-Critic Architecture. Proceedings of the AAAI Conference on Artificial Intelligence, 31(1), Feb. 2017. [5] Andre Barreto, Diana Borsa, Shaobo Hou, Gheorghe Comanici, Eser Aygün, Philippe Hamel, Daniel Toyama, Jonathan hunt, Shibl Mourad, David Silver, and Doina Precup. The option keyboard: Combining skills in reinforcement learning. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019. [6] Christian Daniel, Herke Van Hoof, Jan Peters, and Gerhard Neumann. Probabilistic inference for determining options in reinforcement learning. Machine Learning, 104(2-3):337–357, 2016.   
+[7] Peter Dayan and Geoffrey E Hinton. Feudal Reinforcement Learning. In S. J. Hanson, J. D. Cowan, and C. L. Giles, editors, Advances in Neural Information Processing Systems 5, pages 271–278. Morgan-Kaufmann, 1993. [8] Thomas G. Dietterich. Hierarchical Reinforcement Learning with the MAXQ Value Function Decomposition. Journal of Artificial Intelligence Research, 13(1):227–303, 2000.   
+[9] Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking Deep Reinforcement Learning for Continuous Control. In Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pages 1329–1338. PMLR, 2016.   
+[10] Yan Duan, John Schulman, Xi Chen, Peter L. Bartlett, Ilya Sutskever, and Pieter Abbeel. RL2 : Fast Reinforcement Learning via Slow Reinforcement Learning. CoRR, abs/1611.02779, 2016.   
+[11] Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is All You Need: Learning Skills without a Reward Function. In International Conference on Learning Representations, 2019.   
+[12] Jesse Farebrother, Marlos C. Machado, and Michael Bowling. Generalization and Regularization in DQN. CoRR, abs/1810.00123, 2018.   
+[13] Gregory Farquhar, Shimon Whiteson, and Jakob Foerster. Loaded DiCE: Trading off Bias and Variance in Any-Order Score Function Gradient Estimators for Reinforcement Learning. In Advances in Neural Information Processing Systems, volume 32, pages 8151–8162. Curran Associates, Inc., 2019.   
+[14] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 1126–1135. PMLR, 2017.   
+[15] Jakob Foerster, Gregory Farquhar, Maruan Al-Shedivat, Tim Rocktäschel, Eric Xing, and Shimon Whiteson. DiCE: The Infinitely Differentiable Monte Carlo Estimator. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 1529–1538. PMLR, 2018.   
+[16] Roy Fox, Sanjay Krishnan, Ion Stoica, and Ken Goldberg. Multi-Level Discovery of Deep Options. CoRR, abs/1703.08294, 2017.   
+[17] Kevin Frans, Jonathan Ho, Xi Chen, Pieter Abbeel, and John Schulman. Meta Learning Shared Hierarchies. In International Conference on Learning Representations, 2018.
+
+398 [18] The garage contributors. Garage: A toolkit for reproducible reinforcement learning research.   
+399 https://github.com/rlworkgroup/garage, 2019.   
+400 [19] Abhishek Gupta, Benjamin Eysenbach, Chelsea Finn, and Sergey Levine. Unsupervised   
+401 Meta-Learning for Reinforcement Learning. CoRR, abs/1806.04640, 2018.   
+402 [20] Abhishek Gupta, Russell Mendonca, YuXuan Liu, Pieter Abbeel, and Sergey Levine. Meta  
+403 Reinforcement Learning of Structured Exploration Strategies. In Advances in Neural Informa  
+404 tion Processing Systems, volume 31, pages 5302–5311. Curran Associates, Inc., 2018.   
+405 [21] Jean Harb, Pierre-Luc Bacon, Martin Klissarov, and Doina Precup. When Waiting Is Not an   
+406 Option: Learning Options with a Deliberation Cost. Proceedings of the AAAI Conference on   
+407 Artificial Intelligence, 32(1), 2018.   
+408 [22] Anna Harutyunyan, Will Dabney, Diana Borsa, Nicolas Heess, Remi Munos, and Doina   
+409 Precup. The Termination Critic. In Proceedings of Machine Learning Research, volume 89 of   
+410 Proceedings of Machine Learning Research, pages 2231–2240. PMLR, 2019.   
+411 [23] Maximilian Igl, Andrew Gambardella, Jinke He, Nantas Nardelli, N Siddharth, Wendelin   
+412 Boehmer, and Shimon Whiteson. Multitask Soft Option Learning. In Proceedings of the   
+413 36th Conference on Uncertainty in Artificial Intelligence (UAI), volume 124 of Proceedings of   
+414 Machine Learning Research, pages 969–978. PMLR, 2020.   
+415 [24] George Konidaris and Andrew Barto. Building portable options: Skill transfer in reinforcement   
+416 learning. In Proceedings of the 20th International Joint Conference on Artificial Intelligence,   
+417 pages 895–900, 2007.   
+418 [25] Alexander Li, Carlos Florensa, Ignasi Clavera, and Pieter Abbeel. Sub-policy Adaptation for   
+419 Hierarchical Reinforcement Learning. In International Conference on Learning Representations,   
+420 2020.   
+421 [26] Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-SGD: Learning to Learn Quickly for   
+422 Few Shot Learning. CoRR, abs/1707.09835, 2017.   
+423 [27] Hao Liu, Richard Socher, and Caiming Xiong. Taming MAML: Efficient unbiased meta  
+424 reinforcement learning. In Proceedings of the 36th International Conference on Machine   
+425 Learning, volume 97 of Proceedings of Machine Learning Research, pages 4061–4071. PMLR,   
+426 2019.   
+427 [28] Marlos C. Machado, Marc G. Bellemare, and Michael Bowling. A Laplacian framework for   
+428 option discovery in reinforcement learning. In Proceedings of the 34th International Conference   
+429 on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 2295–   
+430 2304. PMLR, 2017.   
+431 [29] Daniel J Mankowitz, Timothy A Mann, and Shie Mannor. Adaptive skills adaptive partitions   
+432 (asap). In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in   
+433 Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   
+434 [30] Amy McGovern and Andrew G. Barto. Automatic Discovery of Subgoals in Reinforcement   
+435 Learning Using Diverse Density. In Proceedings of the 18th International Conference on   
+436 Machine Learning, ICML ’01, page 361–368, 2001.   
+437 [31] Ishai Menache, Shie Mannor, and Nahum Shimkin. Q-Cut — Dynamic Discovery of Sub-Goals   
+438 in Reinforcement Learning. In Proceedings of the 13th European Conference on Machine   
+439 Learning, ECML’02, page 295–306. Springer-Verlag, 2002.   
+440 [32] Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A Simple Neural Attentive   
+441 Meta-Learner. In International Conference on Learning Representations, 2018.   
+442 [33] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan   
+443 Wierstra, and Martin A. Riedmiller. Playing Atari with Deep Reinforcement Learning. CoRR,   
+444 abs/1312.5602, 2013.   
+445 [34] Ofir Nachum, Shixiang (Shane) Gu, Honglak Lee, and Sergey Levine. Data-Efficient Hierarchi  
+446 cal Reinforcement Learning. In Advances in Neural Information Processing Systems 31, pages   
+447 3303–3313. Curran Associates, Inc., 2018.   
+448 [35] Scott Niekum and Andrew Barto. Clustering via Dirichlet Process Mixture Models for Portable   
+449 Skill Discovery. In Advances in Neural Information Processing Systems, volume 24, pages   
+450 1818–1826. Curran Associates, Inc., 2011.   
+451 [36] Marc Pickett and Andrew G. Barto. Policyblocks: An algorithm for creating useful macro  
+452 actions in reinforcement learning. In Proceedings of the Nineteenth International Conference   
+453 on Machine Learning, pages 506–513. Morgan Kaufmann, 2002.   
+454 [37] Aniruddh Raghu, Maithra Raghu, Samy Bengio, and Oriol Vinyals. Rapid Learning or Feature   
+455 Reuse? Towards Understanding the Effectiveness of MAML. In International Conference on   
+456 Learning Representations, 2020.   
+457 [38] Kate Rakelly, Aurick Zhou, Chelsea Finn, Sergey Levine, and Deirdre Quillen. Efficient Off  
+458 Policy Meta-Reinforcement Learning via Probabilistic Context Variables. In Proceedings of the   
+459 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine   
+460 Learning Research, pages 5331–5340. PMLR, 2019.   
+461 [39] Matthew Riemer, Miao Liu, and Gerald Tesauro. Learning Abstract Options. In Advances in   
+462 Neural Information Processing Systems 31, pages 10424–10434. Curran Associates, Inc., 2018.   
+463 [40] Jonas Rothfuss, Dennis Lee, Ignasi Clavera, Tamim Asfour, and Pieter Abbeel. ProMP: Proximal   
+464 Meta-Policy Search. In International Conference on Learning Representations, 2019.   
+465 [41] John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust   
+466 Region Policy Optimization. In Proceedings of the 32nd International Conference on Machine   
+467 Learning, volume 37 of Proceedings of Machine Learning Research, pages 1889–1897. PMLR,   
+468 2015.   
+469 [42] John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel.   
+470 High-Dimensional Continuous Control Using Generalized Advantage Estimation. CoRR,   
+471 abs/1506.02438, 2015.   
+472 [43] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal   
+473 policy optimization algorithms. CoRR, abs/1707.06347, 2017.   
+474 [44] Matthew Smith, Herke van Hoof, and Joelle Pineau. An Inference-Based Policy Gradient   
+475 Method for Learning Options. In Proceedings of the 35th International Conference on Machine   
+476 Learning, volume 80 of Proceedings of Machine Learning Research, pages 4703–4712. PMLR,   
+477 2018.   
+478 [45] Bradly Stadie, Ge Yang, Rein Houthooft, Peter Chen, Yan Duan, Yuhuai Wu, Pieter Abbeel,   
+479 and Ilya Sutskever. The importance of sampling in meta-reinforcement learning. In Advances   
+480 in Neural Information Processing Systems, volume 31, pages 9280–9290. Curran Associates,   
+481 Inc., 2018.   
+482 [46] Richard S Sutton, Doina Precup, and Satinder Singh. Between MDPs and semi-MDPs: A   
+483 framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):   
+484 181–211, 1999.   
+485 [47] Yee Teh, Victor Bapst, Wojciech M. Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell,   
+486 Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In   
+487 Advances in Neural Information Processing Systems, volume 30, pages 4496–4506. Curran   
+488 Associates, Inc., 2017.   
+489 [48] Sebastian Thrun and Anton Schwartz. Finding structure in reinforcement learning. In G. Tesauro,   
+490 D. Touretzky, and T. Leen, editors, Advances in Neural Information Processing Systems,   
+491 volume 7. MIT Press, 1995.   
+492 [49] E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In 2012   
+493 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 5026–5033, 2012.   
+494 [50] Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg,   
+495 David Silver, and Koray Kavukcuoglu. FeUdal Networks for Hierarchical Reinforcement   
+496 Learning. In Proceedings of the 34th International Conference on Machine Learning, volume 70   
+497 of Proceedings of Machine Learning Research, pages 3540–3549. PMLR, 2017.   
+498 [51] Jane X. Wang, Zeb Kurth-Nelson, Dhruva Tirumala, Hubert Soyer, Joel Z. Leibo, Rémi Munos,   
+499 Charles Blundell, Dharshan Kumaran, and Matthew Botvinick. Learning to reinforcement learn.   
+500 CoRR, abs/1611.05763, 2016.   
+501 [52] Shangtong Zhang and Shimon Whiteson. DAC: The Double Actor-Critic Architecture for   
+502 Learning Options. In Advances in Neural Information Processing Systems, volume 32, pages   
+503 2012–2022. Curran Associates, Inc., 2019.   
+504 [53] Chenyang Zhao, Olivier Sigaud, Freek Stulp, and Timothy M. Hospedales. Investigating   
+505 Generalisation in Continuous Deep Reinforcement Learning. CoRR, abs/1902.07015, 2019.   
+506 [54] Luisa Zintgraf, Kyriacos Shiarli, Vitaly Kurin, Katja Hofmann, and Shimon Whiteson. Fast   
+507 Context Adaptation via Meta-Learning. In Proceedings of the 36th International Conference on   
+508 Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 7693–7702.   
+509 PMLR, 2019.
+
+# 510 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] See Section 6   
+(c) Did you discuss any potential negative societal impacts of your work? [No] We propose a general meta-reinforcement algorithm that does not have any foreseeable negative social impact   
+(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? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+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] In supplemental material   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Some training details are given in Section 5, the rest is provided in Appendix B   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(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] Included in Appendix B
+
+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] We cite the codebases and works that introduced environments we use in Section 5   
+(b) Did you mention the license of the assets? [No] We used publicly available code   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We include our codebase in the supplemental material and will make a public github repository   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] We used publicly available code
+
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We use data from virtual environments
+
+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]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/iklDP-v1sgi/iklDP-v1sgi_content_list.json

@@ -0,0 +1,1104 @@
+[
+    {
+        "type": "text",
+        "text": "Meta Reinforcement Learning for Fast Adaptation of Hierarchical Policies ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            154,
+            821,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            246,
+            579,
+            296
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            329,
+            536,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Hierarchical methods have the potential to allow reinforcement learning to scale to   \n2 larger environments. Decomposing a task into transferable components, however,   \n3 remains a challenging problem. In this paper, we propose a meta-learning approach   \n4 for learning such a decomposition within the options framework. We formulate   \n5 the objective as a bi-level optimization problem in which sub-policies and their   \n6 terminations should facilitate fast learning on a family of tasks. Once such a set   \n7 of options is obtained, it can then be used in new tasks where only the sequencing   \n8 of options needs to be chosen. Our formalism tends to result in options where   \n9 fewer decisions are needed to solve such new tasks. Experimentally, we show that   \n10 our method is able to learn transferable components which accelerate learning and   \n11 performs better than existing methods developed for this setting in the challenging   \n12 ant maze locomotion task. ",
+        "bbox": [
+            151,
+            361,
+            766,
+            513
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "13 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            543,
+            310,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "14 Current state of the art model-free reinforcement learning methods were successfully applied to   \n15 many challenging tasks [33, 41]. However, one of the main drawbacks of these methods is their   \n16 data-inefficiency and inability to generalize to other related tasks [12]. It is often impossible to use   \n17 the agent trained on one task to solve another related task [53] or even to use it as a starting point for   \n18 training because trained models become increasingly exploitative and thus are unable to explore in a   \n19 new task. In such cases, we have to gather new data and train a new model which is time-consuming.   \n20 One way to mitigate this problem is by learning a policy with reusable modules which can be used in   \n21 multiple tasks. For example, if we assume that related tasks contain shared sub-tasks (i.e. tasks come   \n22 from the same family or have hierarchical structure), we can speed up the adaptation to new tasks by   \n23 learning sub-policies that solve these sub-tasks. This is because solutions to new tasks can be created   \n24 by combining known solutions to sub-tasks during adaptation. The idea of learning reusable skills in   \n25 multiple environments, which dates back to at least 1995 [48], was thoroughly explored within the   \n26 options framework [17, 24, 25, 29, 36, 46].   \n27 In this framework, a policy is composed of options (modules that encapsulate sub-policies), and   \n28 a high-level policy that chooses among them. Options have their own termination function, and a   \n29 new option is only initiated when the earlier option terminates. Therefore, options define temporally   \n30 extended behaviors that can form solutions to sub-tasks. Despite extensive research in this area, there   \n31 is not yet a consensus on answers to many important questions about options: What are good options?   \n32 How can we find them? When should a termination occur? How many options should one use? In   \n33 this work our aim will be to find options that allow for fast adaptation to tasks from the same family.   \n34 We use this single principle to address all of these questions except for the number of options which   \n35 we consider a hyperparameter.   \n36 Learning high-level policy, sub-policies and terminations at the same time is a challenging task.   \n37 Recent prior work on options proposed a way to learn both, including the terminations, in an end   \n38 to end manner with policy gradient methods [4, 44]. However, despite achieving good performance   \n39 in single-task settings, these methods often produce options which may not be useful for transfer   \n40 [21, 22]. This is because such options are not explicitly trained for multi-task setting and can often   \n41 terminate too often or not at all [21, 22].   \n42 To overcome this issue, Frans et al. [17] proposed to use such method in a multi-task setting with   \n43 options that have predefined length and are optimized for performance after adaptation of the high  \n44 level policy. Although options that terminate after certain amount of steps simplify the problem   \n45 and work well in some settings [17, 25], manually setting this important hyperparameter requires   \n46 prior knowledge and might not work in cases where options need to have different lengths [23]. For   \n47 example, task where this approach would not be preferable could be driving because some driving   \n48 sub-tasks, such as driving on a highway, are much longer than others, such as driving out from one   \n49 intersection to another in a city. Consequently, capturing the length of both sub-tasks with a single   \n50 hyperparameter [17] or range of hyperparameters [25] can become difficult or even impossible. In   \n51 such cases, learned terminations are preferable.   \n52 In this paper, we propose a method for learning options that allows for fast adaptation to multiple tasks.   \n53 We formalize this notion using recent ideas from gradient based meta-learning [14]. Rather than using   \n54 options with fixed length [17], our algorithm learns both sub-policies and when to terminate options   \n55 using a single meta-learning objective. We hypothesize that this objective implicitly encourages   \n56 options to terminate in a way that yields reusable components. In our experiments, we demonstrate   \n57 the benefits of our approach in a simple Taxi domain as well as in a complex Mujoco [49] Ant Maze   \n58 domain [17]. ",
+        "bbox": [
+            147,
+            573,
+            825,
+            650
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            656,
+            825,
+            745
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            146,
+            750,
+            825,
+            865
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            146,
+            126,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            146,
+            208,
+            825,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            341,
+            825,
+            430
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            164,
+            449,
+            321,
+            463
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since our work builds on insights from both hierarchical reinforcement learning and meta-learning, we present related work in both domains separately, in subsections 2.1 and 2.2 respectively. ",
+        "bbox": [
+            169,
+            479,
+            825,
+            505
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Hierarchical Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            520,
+            475,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "63 One of the aims of hierarchical reinforcement learning is to decompose a complex task or policy into   \n64 simpler units. Popular approaches include learning a diverse set of skills [11] or utilizing the idea of   \n65 Feudal Reinforcement Learning [7, 34, 50]. Another large collection of related work instead relies on   \n66 the options framework [46].   \n67 Some works on options rely on so-called bottleneck states that can be used as sub-goals [30, 31, 35]   \n68 whereas others use spectral clustering to create options [28]. These approaches usually require prior   \n69 knowledge about the environment which restricts their applicability. Different from aforementioned   \n70 methods, end-to-end methods such as the ones which rely on the Option-Critic architecture [4, 39] are   \n71 applicable in more general settings. However, these policy gradient methods can be less efficient than   \n72 concurrently introduced inference based end-to-end methods [6, 16, 44] because they only update the   \n73 option that generated the action whereas inference based methods update options according to their   \n74 responsibilities for each action.   \n75 A common problem with end-to-end methods that learn terminations in a single-task setting is   \n76 option collapse [4]. This causes options to terminate after every action or to never terminate. In   \n77 such cases the learning of terminations can be facilitated by augmenting the objective with entropy   \n78 regularization [44] or deliberation cost [21], regularizing towards a termination prior [23], or by   \n79 optimizing different objective that encourages appropriate terminations [22]. As an alternative, one   \n80 can also use time-based terminations with fixed [17] or randomized length [25]. ",
+        "bbox": [
+            147,
+            545,
+            825,
+            595
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            146,
+            601,
+            825,
+            703
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            709,
+            825,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Meta-Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            802,
+            425,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "82 Meta-reinforcement learning is concerned with producing models which are able to adapt to novel   \n83 tasks quickly. This sub-field includes a broad range of work such as unsupervised methods [11, 19],   \n84 methods that rely on latent variables [20, 38] or methods that learn the update rule of a policy   \n85 [10, 32, 51].   \n86 In contrast with the latter, the recent gradient-based method Model-Agnostic Meta-Learning   \n87 (MAML) [14] assumes that policy parameters are updated with gradient descent and instead aims to   \n88 learn initial parameter values. MAML was extended in followup works that only trained a part of the   \n89 network [37, 54] or showed benefits of different architectural choices such as per-parameter learning   \n90 rates [3, 26]. Several works also focused on MAML in a reinforcement learning setting [2, 27, 45].   \n91 In particular, Al-Shedivat et al. [2] and Stadie et al. [45] pointed out a difference between theory and   \n92 practical implementation of MAML in automatic differentiation frameworks. This issue was further   \n93 discussed and resolved in followup works [13, 15, 40].   \n94 Lastly, there exist methods which do not employ the techniques mentioned above and instead rely   \n95 on the options framework [5, 17, 23–25, 29, 36, 52] or task-specific policies [47]. These approaches   \n96 often make different assumptions about the tasks and settings in which they are applied. Some require   \n97 policies that solve each environment [36] whereas others need environment ID [23, 29] or cumulants   \n98 that properly represents task dynamics [5]. Closest to our work are Meta Learning Shared Hierarchies   \n99 (MLSH) [17] and Adaptive Skills Adaptive Partitions (ASAP) [29]. ASAP uses a policy gradient   \n100 method to optimize immediate performance on multiple tasks with known environment ID but does   \n101 not use neural networks and does not learn terminations. On the other hand, MLSH uses a hierarchical   \n102 structure with predefined options length and a problem setting with unknown environment ID. It   \n103 optimizes for post-adaptation performance by using two alternating phases that either only update   \n104 high-level policy or both high-level policy and sub-policies simultaneously. This approach does not   \n105 use the information from the intermediate adaptation steps when calculating the gradient which can   \n106 negatively affect its accuracy. Additionally, options with fixed length may be difficult to use in some   \n107 settings as we’ve described in Section 1. ",
+        "bbox": [
+            147,
+            826,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            146,
+            126,
+            825,
+            228
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            144,
+            234,
+            825,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "108 3 Background and Notation ",
+        "text_level": 1,
+        "bbox": [
+            144,
+            441,
+            421,
+            457
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will first cover the fundamentals of reinforcement learning, and then focus on the options framework and gradient-based meta-learning. ",
+        "bbox": [
+            161,
+            478,
+            823,
+            504
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "111 3.1 Reinforcement Learning and the Options Framework ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            531,
+            584,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "112 We will consider environments which are episodic Markov decision processes (MDPs). An MDP   \n113 $\\mathcal { M }$ is a tuple $\\langle S , A , p _ { 0 } , P , R , \\gamma \\rangle$ with $S$ being a set of states, $A$ a set of actions, $p _ { 0 } ( s _ { 0 } )$ a probability   \n114 distribution of initial states, $P ( \\pmb { s } ^ { \\prime } | \\pmb { s } , \\pmb { a } )$ a transition probability function, $R ( s , a )$ a reward function   \n115 and $\\gamma$ a discount factor.   \n116 An agent with a stochastic policy $\\pi$ interacts with an environment $\\mathcal { M }$ in the following way. At   \n117 every timestep $t$ , the agent receives a state of the environment $\\textbf { \\textit { s } } _ { t } ~ \\in ~ \\textbf { \\textit { S } }$ and selects an action   \n118 $\\mathbf { \\Sigma } _ { \\mathbf { \\Phi } _ { t } } ~ \\in ~ \\mathbf { \\Sigma } _ { A }$ according to conditional distribution $\\pi ( \\mathbf { \\boldsymbol { a } } _ { t } | \\mathbf { \\boldsymbol { s } } _ { t } )$ . Depending on the current state and the   \n119 action performed, the environment provides the agent with a new state $s _ { t + 1 } \\sim P ( s _ { t + 1 } | s _ { t } , \\mathbf { a } _ { t } )$ and   \n120 a scalar reward $r _ { t } = R ( s _ { t } , { \\pmb a } _ { t } )$ . This process is repeated until a so-called terminal state is reached.   \n121 We define a trajectory $\\tau$ as an ordered sequence of all states actions and rewards in a single episode   \n122 $\\tau = ( s _ { 0 } , { \\pmb a } _ { 0 } , r _ { 0 } , . . . , s _ { T } ) .$ . Similarly, the history at timestep $t$ consists of all states and actions preceding   \n123 $\\mathbf { } \\mathbf { a } _ { t }$ , $\\pmb { h } _ { t } = ( \\pmb { s } _ { 0 } , \\pmb { a } _ { 0 } , . . . , \\pmb { s } _ { t } )$ . The state value function is defined as $V _ { \\pi } ( \\pmb { s } ) = \\mathbb { E } _ { \\pi } \\left[ G _ { t } | \\pmb { s } _ { t } = \\pmb { s } \\right]$ where the   \n124 discounted return at timestep $t$ is defined as $\\begin{array} { r } { G _ { t } ( \\tau ) = \\sum _ { t ^ { \\prime } = t } ^ { T } \\gamma ^ { ( t - t ^ { \\prime } ) } r _ { t ^ { \\prime } } } \\end{array}$ .   \n125 The agent’s objective is to maximize the expected discounted return $J ~ = ~ \\mathbb { E } _ { p ( \\tau \\mid \\theta ) } \\left[ G _ { 0 } ( \\tau ) \\right]$ .   \n126 127 $\\begin{array} { r } { \\nabla _ { \\theta } J \\approx \\mathbb { E } _ { p ( \\tau | \\theta ) } [ \\sum _ { t = 0 } ^ { T } \\nabla _ { \\theta } \\log \\pi _ { \\theta } ( \\mathbf { a } _ { t } | \\mathbf { s } _ { t } ) \\mathbf { } \\mathbf { } \\mathbf { } A _ { t } ] } \\end{array}$ gradient descent by estimating thusing Monte Carlo sampling, where $A _ { t }$ policy gradientis an advantage   \n128 estimator such as the generalized advantage estimator $A _ { t } ^ { G A E }$ [42].   \n129 The options framework is a framework for temporal abstraction that consists of options   \n130 $\\omega = \\langle \\bar { \\mathcal { T } } ^ { \\omega } , \\pi ^ { \\omega } , \\xi ^ { \\omega } \\rangle$ and a policy over options $\\pi ^ { \\Omega } ( \\omega | s )$ . Each option $\\omega$ consists of an initiation set, a   \n131 sub-policy and a termination function. The initiation set ${ \\mathcal { T } } ^ { \\omega }$ is a set of states in which an option can   \n132 be selected (initiated) and in our case it is the whole state space $( \\mathbb { Z } ^ { \\omega } = S$ ). A sub-policy $\\bar { { \\boldsymbol { \\pi } } } ^ { \\omega } ( a | s )$ ,   \n133 also called low-level policy, is a regular policy that acts in the environment. Lastly, the termination   \n134 condition $\\xi ^ { \\omega } ( s )$ is a function that outputs the probability of termination for the option in a given state.   \n136 Model-Agnostic Meta-Learning (MAML) [14] is a meta-learning technique that trains a model for   \n137 maximum post-adaptation performance on a distribution of tasks. The adaptation consists of one or   \n138 several inner gradient updates. If we consider an estimator $f _ { \\theta }$ with parameters $\\theta$ and a task-specific   \n139 loss $\\mathcal { L } _ { \\mathcal { M } _ { i } }$ , a supervised learning objective with a single inner update can be formalized as shown in   \n140 Equation 1. In order to optimize this objective one only needs to take a gradient of this expression.   \n141 This can be easily achieved with automatic differentiation frameworks by creating a backpropagation   \n142 graph for the gradient. ",
+        "bbox": [
+            142,
+            560,
+            825,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            617,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            739,
+            826,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            801,
+            825,
+            878
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            148,
+            825,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/992a64042b96c37d3cddbb155ad42794b1549d71f2a3cc99a728b303b3e80935.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { \\mathcal { M } } \\left[ \\mathcal { L } _ { \\mathcal { M } _ { i } } ( f _ { \\theta ^ { \\prime } } ) \\right] = \\operatorname* { m i n } _ { \\theta } \\sum _ { \\mathcal { M } _ { i } \\sim p ( \\mathcal { M } ) } \\mathcal { L } _ { \\mathcal { M } _ { i } } ( f _ { \\theta - \\alpha \\nabla _ { \\theta } \\mathcal { L } _ { \\mathcal { M } _ { i } } ( f _ { \\theta } ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            243,
+            695,
+            278
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "143 One can similarly use this approach with a reinforcement learning objective. However, the implemen  \n144 tation with an automatic differentiation framework differs because a simple backpropagation through   \n145 the computation graph of the gradient produces biased gradients [2, 45]. This is due to an additional   \n146 dependency of the sampling distribution on parameters that is not present in the supervised learning   \n147 objective. To produce correct higher order gradients with automatic differentiation frameworks in   \n148 a reinforcement learning setting, one can use the objective in Equation 3 as proposed by Farquhar   \n149 et al. [13]. This objective utilizes the DiCE operator $\\boxdot$ [15] which can be implemented according   \n150 to Equation 2 where $\\bot ( x )$ is a stop gradient operator that evaluates to $x$ but returns a zero gradient   \n151 when differentiated. ",
+        "bbox": [
+            141,
+            281,
+            826,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fdd10611c47b4d571e973227bbb476d282760d444a175525449c6debd17e79f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\Xi ( \\mathbf { a } _ { t } ) = \\exp \\left[ \\log \\pi _ { \\theta } ( \\mathbf { a } _ { t } | s _ { t } ) - \\perp ( \\log \\pi _ { \\theta } ( \\mathbf { a } _ { t } | s _ { t } ) ) \\right] , \\quad \\nabla _ { \\theta } \\mathbb { E } _ { \\tau \\sim p ( \\tau | \\theta ) } \\left[ G _ { 0 } ^ { M _ { i } } ( \\tau ) \\right] \\approx \\nabla _ { \\theta } J _ { \\bigstar } \\pi _ { \\star } ( \\tau ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            401,
+            779,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "152 ",
+        "bbox": [
+            141,
+            425,
+            161,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6fcb5e578760930c9808e854893ca3eed7a9424fc446a33df8719ba97ad4ea4f.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J _ { \\bigstar \\bigstar } = \\mathbb { E } _ { \\tau \\sim p ( \\tau | \\theta ) } \\left[ \\sum _ { t = 0 } ^ { T } \\nabla _ { \\theta } \\bigg ( \\prod _ { t ^ { \\prime } = 0 } ^ { t } \\Xi ( a _ { t ^ { \\prime } } ) \\lambda ^ { t - t ^ { \\prime } } A _ { t } ^ { G A E } - \\prod _ { t ^ { \\prime } = 0 } ^ { t - 1 } \\Xi ( a _ { t ^ { \\prime } } ) \\lambda ^ { t - t ^ { \\prime } } A _ { t } ^ { G A E } \\bigg ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            438,
+            778,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "153 4 Fast Adaptation of Modular Policies ",
+        "text_level": 1,
+        "bbox": [
+            141,
+            492,
+            509,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "154 Much of the extensive research in the options framework has focused on an intuition of options   \n155 capturing useful sub-tasks [4, 17, 36, 46]. However, there is no consensus about capturing this   \n156 intuition in an objective function or the best way to find such options. We propose a conceptually   \n157 simple objective: a good set of options allows quick adaptation to many novel tasks. This can   \n158 be formulated using the MAML framework [14], where we consider a setting in which there is a   \n159 distribution of tasks $p ( \\mathcal { M } )$ with similar (hierarchical) structure but different reward or transition   \n160 functions. Our goal is then to maximize the expected performance after $L$ adaptation steps of the   \n161 hierarchical policy parametrized by $\\theta$ : ",
+        "bbox": [
+            139,
+            520,
+            825,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64a41db6f37ef0707576f9709b53421ff298439214674d5fb6e048547a68a477.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\theta } \\sum _ { M _ { i } \\sim p ( \\mathcal { M } ) } \\mathbb { E } _ { \\tau ^ { L } \\sim p ( \\tau ^ { L } \\mid \\theta ^ { L } ) } \\left[ G _ { 0 } ^ { M _ { i } } ( \\tau ^ { L } ) \\right] , \\quad \\theta ^ { j + 1 } = \\theta ^ { j } + \\alpha _ { i n } \\nabla _ { \\theta ^ { j } } \\mathbb { E } _ { \\tau ^ { j } \\sim p ( \\tau ^ { j } \\mid \\theta ^ { j } ) } \\left[ G _ { 0 } ^ { M _ { i } } ( \\tau ^ { j } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            627,
+            794,
+            663
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "162 Using conventional MAML means adapting a large number of parameters which can be disadvanta  \n163 geous, as was demonstrated by Zintgraf et al. [54] and Antoniou et al. [3]. By reducing the number of   \n164 parameters that are tuned during the adaptation phase, one can reduce the complexity of the problem   \n165 during test time at the cost of a less expressive policy. We thus split the parameters into an inner group   \n166 $\\theta _ { \\mathrm { i n } }$ and an outer group $\\theta _ { \\mathrm { o u t } }$ where inner parameters are updated during the adaptation step and outer   \n167 parameters are optimized in the outer objective. Note that when using such split, the initialization   \n168 values of inner parameters may also be meta-learned [54]. We experimented with both versions and   \n169 observed that fixed initialization values performed better. Similarly, the per-parameter inner learning   \n170 rate $\\alpha _ { i n }$ [3, 26] can also be meta-learned to allow for more complex inner updates. We used this   \n171 approach in a setting with more complex environment.   \n172 Our option model has three sets of parameters: those of the high-level policy network $\\theta _ { \\Omega }$ , sub-policy   \n173 networks $\\theta _ { \\omega }$ and termination networks $\\theta _ { \\xi }$ . We now divide these over the inner and outer parameter   \n174 group. Since we assume that tasks with common sub-problems can be solved using identical options,   \n175 we consider the sub-policy and termination function parameters as outer parameters. On the other   \n176 hand, since in each task the decision of the high-level policy to choose options would be different,   \n177 its parameters constitute the inner group. By keeping sub-policies fixed during the adaptation and ",
+        "bbox": [
+            141,
+            668,
+            825,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            800,
+            826,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "initialize θΩ, θξ , θω , αin , αout   \nset $\\theta _ { i n } = \\theta _ { \\Omega }$   \nset $\\theta _ { o u t } = \\{ \\theta _ { \\xi } , \\theta _ { \\omega } \\}$   \nrepeat Set gradient of outer parameters $\\mathbf { \\nabla } _ { \\mathbf { \\theta } _ { \\partial u t } } \\mathbf { \\Psi } = 0$ for $n = 1$ to $N$ do set $\\theta _ { i n } ^ { \\prime } = \\theta _ { i n }$ sample a task $\\mathcal { M } \\sim p ( \\mathcal { M } )$ for $l = 1$ to $L + 1$ do sample $k$ episodes $\\tau _ { 1 : k }$ on $\\mathcal { M }$ using $\\pi _ { \\{ \\theta _ { i n } ^ { \\prime } , \\theta _ { o u t } \\} }$ fit a baseline Vκ using data from τ1:k compute $A _ { t } ^ { G A \\ddot { E } }$ for all $\\tau _ { 1 : k }$ compute $\\log \\pi ( \\boldsymbol { a } _ { t } | \\boldsymbol { h } _ { t } ) = \\mathbb { E } _ { \\omega | \\boldsymbol { h } _ { t } } [ \\pi ^ { \\omega } ( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } ) ]$ compute $J _ { \\bigodot }$ with $A _ { t } ^ { G A E } , \\log \\pi ( { \\pmb a } _ { t } | { \\pmb h } _ { t } )$ (Eqs. 2, 3) if $l < L + \\overline { { 1 } }$ then $\\theta _ { i n } ^ { \\prime } = \\theta _ { i n } ^ { \\prime } + \\alpha _ { i n } \\nabla _ { \\theta _ { i n } ^ { \\prime } } J _ { \\overline { { \\mathbf { \\bullet } } } }$ else $\\begin{array} { c } { { { \\pmb g } _ { \\theta _ { o u t } } = { \\pmb g } _ { \\theta _ { o u t } } + \\nabla _ { \\theta _ { o u t } } J _ { \\pmb { \\left[ \\pmb { \\hat { \\backprime } } \\right] } } } } \\\\ { { \\theta _ { o u t } = \\theta _ { o u t } + \\alpha _ { o u t } \\frac { 1 } { N } { \\pmb g } _ { \\theta _ { o u t } } } } \\end{array}$   \nuntil convergence ",
+        "bbox": [
+            181,
+            142,
+            566,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "178 restricting the update to the high-level policy, we optimize for options that can be used to solve   \n179 multiple tasks, thereby allowing the overall policy to adapt quickly with the change of high-level   \n180 policy. This also allows for an expressive policy which can capture different behaviors and reduces   \n181 the number of parameters and decisions an agent needs to learn and make during test time.   \n182 Formally, our final objective can be expressed as Equation 5 with the inner update given by Equation   \n183 6. The objective is similar to the one used in MLSH [17] with some key differences. Firstly, by   \n184 backpropagating through the update step we are able to capture additional information from the   \n185 adaptation steps in the gradient and secondly, our objective includes the optimization of termination   \n186 parameters and thus allows for options with different lengths. ",
+        "bbox": [
+            141,
+            432,
+            825,
+            485
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            489,
+            823,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/69ea2f1eca629fe2f635d907673b509e3b8a01b01da775c504c75d4a695e966b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle \\operatorname* { m a x } _ { \\theta _ { \\omega } , \\theta _ { \\xi } } \\sum _ { { \\mathcal M } _ { i } \\sim p ( { \\mathcal M } ) } { \\mathbb E } _ { \\tau \\sim p ( \\tau \\mid \\{ \\theta _ { \\omega } , \\theta _ { \\xi } , \\theta _ { \\Omega } ^ { L } \\} ) } \\left[ G _ { 0 } ^ { { \\mathcal M } _ { i } } ( \\tau ) \\right] } \\\\ & { \\displaystyle \\theta _ { \\Omega } ^ { j + 1 } = \\theta _ { \\Omega } ^ { j } + \\alpha _ { i n } \\nabla _ { \\theta _ { \\Omega } ^ { j } } { \\mathbb E } _ { \\tau \\sim p ( \\tau \\mid \\{ \\theta _ { \\omega } , \\theta _ { \\xi } , \\theta _ { \\Omega } ^ { j } \\} ) } \\left[ G _ { 0 } ^ { { \\mathcal M } _ { i } } ( \\tau ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            322,
+            558,
+            673,
+            620
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "187 4.1 Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            631,
+            285,
+            644
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "188 Written in its general form the objective leaves some freedom with regard to which policy gradient   \n189 algorithm is used for gradient calculation. In our work we use the Inferred Option Policy Gradient   \n190 (IOPG) [44] because it updates all options at the same time based on their responsibilities, i.e., the   \n191 probability that the option was active given the history $\\pmb { h } _ { t }$ of states and actions so far. This can lead to   \n192 better data-efficiency when compared to other methods that only update a single option at a time but   \n193 comes at the cost of increased computation time. Another important design choice is the state value   \n194 function estimator. In the MAML RL setting the policy constantly changes in every inner update. It is   \n195 thus difficult to use past trajectories for fitting the value function. We therefore use a linear time-state   \n196 dependent baseline [9] which works better than more complex baselines with little data and was also   \n197 used in the original MAML implementation.   \n198 The resulting algorithm for Fast Adaptation of Modular Policies (FAMP) is outlined in Algorithm 1.   \n199 Note that in order to use IOPG with DiCE we replace $\\pi ( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } )$ with $\\pi ( \\mathbf { \\boldsymbol { a } } _ { t } | \\mathbf { \\boldsymbol { h } } _ { t } )$ in Equation 2. An   \n200 intuition about why this is possible comes from the fact that we can easily formulate a new MDP   \n201 $\\tilde { \\mathcal { M } }$ in which states $\\tilde { s } _ { t }$ are histories $\\pmb { h } _ { t }$ of the original MDP without otherwise altering the dynamics.   \n202 After $L$ inner updates, the gradient of the objective with respect to the outer parameters is calculated.   \n203 In principle, we would like to optimize for performance after a moderate number of gradient updates   \n204 $L$ such as 10 or 20. However, with more inner updates the resulting gradient of the objective becomes   \n205 noisier due to the usage of Monte Carlo estimate in each inner update. Furthermore, the time   \n206 complexity of gradient computation and sample complexity both scale linearly with the number of   \n207 inner updates. In practice we found a range from 2 to 4 update steps to be acceptable. An important   \n208 benefit of gradient-based meta-learning is that even though the model is optimized for performance   \n209 after $L$ adaptation steps, it can still be improved after $L$ updates by performing more steps of gradient   \n210 descent. ",
+        "bbox": [
+            141,
+            653,
+            825,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            785,
+            826,
+            878
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/11b10b77111fd2ba86e496f0980568cdb89d2062317dcefd5b981c41fe2f00f5.jpg",
+        "image_caption": [
+            "Figure 1: Left: Map of a taxi environment with special states and an example task. Middle and Right: Visualization of the option usage in this task. Middle part shows states without passenger on board. Right part shows states with passenger. Arrows represent directional actions, pick-up/drop-off is shown as a square. Each action is colored according to the active option. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            262,
+            124,
+            736,
+            235
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            319,
+            825,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            416,
+            312,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we empirically evaluate our method and show its benefits when applied to randomly selected tasks within and outside of the training distribution. ",
+        "bbox": [
+            168,
+            445,
+            821,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "214 5.1 Taxi ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            487,
+            243,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "215   \n216   \n217   \n218   \n219   \n220   \n221   \n222   \n223   \n224   \n225   \n226   \n227   \n228 ",
+        "bbox": [
+            142,
+            510,
+            159,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the first set of experiments we use a modified Taxi environment1 [8] displayed in Figure 1. An agent acts as a taxi driver who starts in one of the special (colored) locations. The goal of the driver is then to drive a passenger from one of the special locations to his destination. The task family consists of 60 different tasks with different combination of start, goal and passenger positions. These are always initialized in special states. In 12 out of 60 easier configurations the passenger starts the episode in the car. The only restriction on start, goal and passenger positions in all cases is that passenger’s destination must not be the same as his initial position. Each task is an MDP in which the agent can use 4 directional actions and two special actions: pick-up/drop-off and no-op. The state space is represented as a one-hot vector with 72 entries for every combination of possible taxi location and passenger being on board. Thus the agent does not have any information about the location of the passenger or goal state. Therefore, in order to facilitate fast adaptation to the (unobservable) passenger and goal locations, the agent must acquire options that can serve as building blocks for exploration. The reward is 2 for reaching the goal and $- 0 . 1$ per step otherwise. To speed up training in the early phases, we terminate the episode if it takes longer than 1500 timesteps. ",
+        "bbox": [
+            171,
+            511,
+            825,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "229   \n230   \n231   \n232   \n233   \n234   \n235   \n236   \n237   \n238   \n23 ",
+        "bbox": [
+            141,
+            694,
+            161,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we use tabular representations implemented as a combination of linear layer and non-linearity for the policy over options, terminations and sub-policies such that each one-hot state has its own set of parameters. We use 48 training tasks to train sub-policies and terminations with our algorithm. Learned terminations and sub-policies are then kept fixed during test time and only the policy over options is updated. Performance is then compared on the remaining 12 test tasks (selected to use combinations of special locations with similar frequency) to MLSH and two baselines. We chose MLSH because it is a closest hierarchical method designed for our setting in which there is no extra information about the environment available. This is in contrast with many other hierarchical [5, 23, 29] and non-hierarchical [38, 47] meta-reinforcement learning methods which utilize extra information such as the ID of a sampled environment. ",
+        "bbox": [
+            171,
+            694,
+            825,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "9 Similarly to our method, MLSH is trained on all training tasks and evaluated with fixed sub-policies.   \n0 The multi-task baseline is an IOPG algorithm that learns a shared policy (including high-level policy)   \n241 by optimizing average return over tasks rather than the meta-learning objective in Equations 5 and   \n242 6. After the training, it only adapt its high-level policy on test tasks. We expect this baseline to   \n243 perform poorly in the long run because it does not optimize for post-update performance. Lastly,   \n244 the single-task baseline is an IOPG algorithm that learns the test tasks from scratch without any   \n245 pre-training. Therefore, since it does not need to generalize to many tasks and has a policy with   \n246 enough capacity, we expect that it should eventually outperform other methods after sufficiently   \n247 long training. However, meta-learned policy with desirable options should find good solution much   \n248 quicker. To make the single-task baseline as strong as possible, we set its learning rate to the highest   \n249 value that was able to solve all tasks reliably. ",
+        "bbox": [
+            156,
+            827,
+            825,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6cbe98a638d7064b46eaf89975adaf7d9fc316d9e522d9fb12da6bd7130c4124.jpg",
+        "image_caption": [
+            "Figure 2: Left: Average performance of different algorithms on taxi environment test tasks. Plot shows mean and standard deviation over 5 seeds. Right: Average performance of our method with different hyperparameter values on taxi environments test tasks. Plot shows median and interquartile range over 5 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            123,
+            759,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            353,
+            825,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "250 Results ",
+        "text_level": 1,
+        "bbox": [
+            141,
+            473,
+            226,
+            485
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "51 As shown in Figure 2, our method is able to outperform both MLSH and the multi-task baseline   \n252 reaching the final performance of $- 0 . 3 1 5$ . Furthermore, it also outperforms all other algorithms   \n253 in terms of adaptation speed. We additionally checked whether the single-task baseline eventually   \n254 overtakes FAMP and found that after more than 200 episodes, its performance stabilizes at a final   \n255 discounted return value of $- 0 . 2 8 4$ . This demonstrates that FAMP can learn sub-policies and termi  \n256 nations that allow for fast adaptation in similar unseen environments at the cost of slightly lower   \n257 asymptotic performance. An example trajectory that was produced by the agent in one of the hardest   \n258 test tasks is displayed in Figure 1. In this task, the agent is able to combine three options to form an   \n259 optimal solution. Plots with meta-training curves and learned options are included in Appendix C.   \n260 In Figure 2 (right), we show how the performance varies with changes to important hyperparameters,   \n261 namely, the number of options and adaptation steps. We observe that decreasing the number of   \n262 adaptation steps during training to one leads to a clear drop in performance. This can be attributed to   \n263 the policy not being able to switch from exploratory to exploitatory behavior in a single inner update   \n264 as well as the smaller amount of data observed before each outer update.   \n265 Unlike the number of adaptation steps, the number of options does not seem to affect the performance   \n266 too much. The only noticeable exception is lower performance when using only 2 options. This   \n267 exception can be explained by noticing that in some states one needs to perform 3 different actions   \n268 to represent all optimal paths. As an example, consider the state two squares above the blue special   \n269 state in Figure 1. To reach the blue state in the minimum number of steps the agent needs to use the   \n270 down action. Similarly, to go from the blue state to the red or yellow one it needs to use up and right   \n271 respectively. Thus the agent cannot represent the optimal policies with only 2 options. Interestingly,   \n272 even in this case, the agent is still able to separate trajectories in such a way that it can reach all goals   \n273 albeit with slightly worse performance.   \n274 This outcome demonstrates another benefit of learned option lengths as the optimal option length   \n275 does not only depend on tasks and their difficulty but also on the number of options that are available.   \n276 To illustrate this, consider an extreme case where there are as many options as tasks. In this case, it   \n277 would be sensible to have solution to a different task in each option and not terminate at all because   \n278 each task would be solved with only one high-level action. However, as the number of available   \n279 options decreases, sharing options between tasks becomes necessary and terminations should start to ",
+        "bbox": [
+            149,
+            492,
+            825,
+            606
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            612,
+            825,
+            675
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            681,
+            825,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            801,
+            825,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Percentage of terminations in trajectories obtained from adapted policies averaged over 5 seeds. Standard deviations are in $1 \\%$ range. ",
+        "bbox": [
+            169,
+            130,
+            823,
+            156
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4f4daa24e9ebbd250cde0424bb556b18de9d45b0e280a3f86a566ab508c037e5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Number of options</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>16</td></tr><tr><td rowspan=1 colspan=1>Avg. terminations in traj</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>63%</td><td rowspan=1 colspan=1>57%</td><td rowspan=1 colspan=1>55%</td><td rowspan=1 colspan=1>44%</td><td rowspan=1 colspan=1>28%</td></tr></table>",
+        "bbox": [
+            260,
+            158,
+            737,
+            190
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2be204a1d222a55fbe76bab216be6e5236945ba7b5f170a1f816e2c217132a2a.jpg",
+        "image_caption": [
+            "Figure 3: Ant maze tasks. The agent needs to control a simulated 4-legged ant-like robot and move it towards the green square. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            270,
+            204,
+            727,
+            342
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "280 occur to allow for all tasks to be solved. Moreover, if the number of options is decreased even further,   \n281 there may not be enough to options to capture the optimal behavior for all tasks. Consequently, it   \n282 becomes even more difficult to choose the appropriate option length a priori since it can depend on   \n283 the number of available options. To confirm this intuition, we ran a followup experiment with longer   \n284 time horizon in the taxi environment. While the trajectories produced by adapted policies had similar   \n285 length, relative number of terminations decreased with the increase in the number of options as shown   \n286 in Table 1. ",
+        "bbox": [
+            141,
+            400,
+            825,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "287 5.2 Ant Maze ",
+        "text_level": 1,
+        "bbox": [
+            141,
+            506,
+            280,
+            519
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "288 In our second experiment, we demonstrate the applicability of our method to more complex environ  \n289 ments. We use the family of ant maze tasks introduced by Frans et al. [17] shown in Figure 3. This   \n290 allows us to reproduce the results of MLSH as closely as possible by mirroring the setting used in   \n291 the original paper. In addition to MLSH, we also compare to $\\mathtt { R L } ^ { 2 }$ , a non-hierarchical meta-learning   \n292 algorithm designed for fast-adaptation and Proximal Policy Optimization (PPO) [43], which serves   \n293 as a strong single-task baseline.   \n294 In each task the agent needs to move a simulated 4-legged ant-like robot through a small maze towards   \n295 the goal. Both state space and action space are continuous with 29 and 8 dimensions respectively   \n296 and each episode lasts 1000 timesteps. States do not contain any information about the maze layout   \n297 or the location of the goal. The original implementation also resets the orientation of the ant every   \n298 200 steps. However, we removed these resets because they made the MDP partially observable,   \n299 introduced discontinuities and were not realistic for the robotics scenario they are supposed to imitate.   \n300 Results of experiments with the original implementation are similar to the ones we present. They can   \n301 be found in Appendix C along with meta-training plots.   \n302 Both FAMP and MLSH use the same architecture with two hidden layers of 64 nodes to represent the   \n303 high-level policy, sub-policies and terminations (only applies to FAMP). We used existing repositories   \n304 for the implementation of $\\mathtt { R L } ^ { 2 }$ [18] and PPO [1]. Hyperparameter values can be found in Appendix   \n305 B. During the training phase, sub-policies (and terminations) of both hierarchical algorithms were   \n306 trained on all tasks until the return averaged over all environments stopped improving. In the test   \n307 phase all parameters except for the policy over options were frozen. Similarly, $\\hat { { \\mathrm { R L } } ^ { 2 } }$ was pre-trained   \n308 on all tasks and subsequently evaluated while PPO was trained from scratch.   \n309 The comparison of the performance and speed of adaptation can be seen in Figure 4 (left). Our   \n310 method achieves superior performance reaching an average return of 1330. We also observed a   \n311 similar trend across individual environments. Plots of these comparisons are available in Appendix C.   \n312 While the zero-shot performance of $\\mathtt { R L } ^ { 2 }$ is slightly better than FAMP, it often struggles to further   \n313 adapt to specific tasks and quickly gets outperformed by both hierarchical methods. This is likely be   \n314 due to the objective that optimizes average return over all training episodes and not post-adaptation   \n315 performance directly. Lastly, PPO continuously improves but its performance does not come close to   \n316 the meta-learning algorithms. After about 1000 episodes it reaches the performance of MLSH and if   \n317 ran sufficiently long , we would expect that it would eventually catch up to FAMP.   \n318 We visualize the option usage of FAMP on two example tasks in Figure 4 (right). After the high-level   \n319 policy is fine-tuned, we use the $x$ and $y$ positions of the ant in 3 sampled trajectories to highlight   \n320 which option is active at each part of the state space. Although we only take 2 out of 29 dimensions   \n321 into account, we are still able to get useful insight about the learned option structure. In the task that   \n322 is depicted in the left part of the plot, the agent uses the blue option before switching to cyan in the   \n323 middle and finishing with a combination of blue and purple. On the other hand, in the right task, the   \n324 agent uses a combination of blue and purple to move down instead of to the right. This shows that the   \n325 agent learned a useful abstraction that allows it to perform two different useful behaviors in similar   \n326 parts of the state space by using terminations and different options. ",
+        "bbox": [
+            144,
+            530,
+            825,
+            606
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            611,
+            825,
+            714
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            719,
+            825,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            814,
+            825,
+            878
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9bef7bf587ff121b72310db790213d994ef96fa9a115b07729a272de2bdff666.jpg",
+        "image_caption": [
+            "Figure 4: Left: Average performance of algorithms on ant maze environments tasks. Plot shows mean and standard deviation over 3 seeds. Right: Option usage visualization on ant maze tasks. Both plots were created using positions of the ant during 3 trajectories. Each of the 3 options is represented by a different color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            122,
+            821,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            351,
+            825,
+            403
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            139,
+            409,
+            825,
+            524
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "327 6 Discussion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            144,
+            551,
+            442,
+            567
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "328 In this work, our aim was to learn both sub-policies and terminations of options by using a single   \n329 simple principle: options should accelerate adaptation in many tasks. We proposed a method for   \n330 learning hierarchical policies that combines the options framework with gradient-based meta-learning   \n331 and explicitly optimizes for performance after several adaptation steps. In our experiments, we   \n332 have demonstrated the benefits of our approach in quickly learning previously unseen test tasks.   \n333 Furthermore, we have shown that the proposed method outperforms the closest hierarchical and   \n334 non-hierarchical meta-reinforcement learning methods designed for similar setting in a challenging   \n335 multi-task learning scenario.   \n336 The computation limitations of our method are mostly connected to the calculation of responsibilities   \n337 in IOPG. In this calculation, many sequential matrix multiplications are required both in the forward   \n338 and backward pass. The compute time for each update is thus dependent on the trajectory length   \n339 because these calculations cannot be done in parallel. One direction for future work could thus be   \n340 alleviating this limitation.   \n341 Our objective does not explicitly constrain the number of terminations as long as they lead to fast   \n342 adaptation. Thus, there are many combinations of options with different lengths which can lead to   \n343 good performance on all tasks, which do not always correspond to intuitive decompositions. One   \n344 possible cause of spurious terminations lies in the continuous state space used in some tasks. When   \n345 neural networks are used to represent termination functions, they learn to generalize to nearby states.   \n346 In tasks such as the ant maze, the agent will visit many states in the same neighborhood and might   \n347 thus terminate options several times in quick succession. A promising topic for future investigation is   \n348 whether this problem could be alleviated by using terminations that also depend on the state in which   \n349 the option was initiated. ",
+        "bbox": [
+            141,
+            586,
+            825,
+            688
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            694,
+            825,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            141,
+            763,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            124,
+            267,
+            139
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Joshua Achiam. Spinning Up in Deep Reinforcement Learning. 2018. [2] Maruan Al-Shedivat, Trapit Bansal, Yura Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel. Continuous Adaptation via Meta-Learning in Nonstationary and Competitive Environments. In International Conference on Learning Representations, 2018. [3] Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your MAML. In International Conference on Learning Representations, 2019.   \n[4] Pierre-Luc Bacon, Jean Harb, and Doina Precup. The Option-Critic Architecture. Proceedings of the AAAI Conference on Artificial Intelligence, 31(1), Feb. 2017. [5] Andre Barreto, Diana Borsa, Shaobo Hou, Gheorghe Comanici, Eser Aygün, Philippe Hamel, Daniel Toyama, Jonathan hunt, Shibl Mourad, David Silver, and Doina Precup. The option keyboard: Combining skills in reinforcement learning. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019. [6] Christian Daniel, Herke Van Hoof, Jan Peters, and Gerhard Neumann. Probabilistic inference for determining options in reinforcement learning. Machine Learning, 104(2-3):337–357, 2016.   \n[7] Peter Dayan and Geoffrey E Hinton. Feudal Reinforcement Learning. In S. J. Hanson, J. D. Cowan, and C. L. Giles, editors, Advances in Neural Information Processing Systems 5, pages 271–278. Morgan-Kaufmann, 1993. [8] Thomas G. Dietterich. Hierarchical Reinforcement Learning with the MAXQ Value Function Decomposition. Journal of Artificial Intelligence Research, 13(1):227–303, 2000.   \n[9] Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking Deep Reinforcement Learning for Continuous Control. In Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pages 1329–1338. PMLR, 2016.   \n[10] Yan Duan, John Schulman, Xi Chen, Peter L. Bartlett, Ilya Sutskever, and Pieter Abbeel. RL2 : Fast Reinforcement Learning via Slow Reinforcement Learning. CoRR, abs/1611.02779, 2016.   \n[11] Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is All You Need: Learning Skills without a Reward Function. In International Conference on Learning Representations, 2019.   \n[12] Jesse Farebrother, Marlos C. Machado, and Michael Bowling. Generalization and Regularization in DQN. CoRR, abs/1810.00123, 2018.   \n[13] Gregory Farquhar, Shimon Whiteson, and Jakob Foerster. Loaded DiCE: Trading off Bias and Variance in Any-Order Score Function Gradient Estimators for Reinforcement Learning. In Advances in Neural Information Processing Systems, volume 32, pages 8151–8162. Curran Associates, Inc., 2019.   \n[14] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 1126–1135. PMLR, 2017.   \n[15] Jakob Foerster, Gregory Farquhar, Maruan Al-Shedivat, Tim Rocktäschel, Eric Xing, and Shimon Whiteson. DiCE: The Infinitely Differentiable Monte Carlo Estimator. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 1529–1538. PMLR, 2018.   \n[16] Roy Fox, Sanjay Krishnan, Ion Stoica, and Ken Goldberg. Multi-Level Discovery of Deep Options. CoRR, abs/1703.08294, 2017.   \n[17] Kevin Frans, Jonathan Ho, Xi Chen, Pieter Abbeel, and John Schulman. Meta Learning Shared Hierarchies. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            136,
+            146,
+            828,
+            884
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "398 [18] The garage contributors. Garage: A toolkit for reproducible reinforcement learning research.   \n399 https://github.com/rlworkgroup/garage, 2019.   \n400 [19] Abhishek Gupta, Benjamin Eysenbach, Chelsea Finn, and Sergey Levine. Unsupervised   \n401 Meta-Learning for Reinforcement Learning. CoRR, abs/1806.04640, 2018.   \n402 [20] Abhishek Gupta, Russell Mendonca, YuXuan Liu, Pieter Abbeel, and Sergey Levine. Meta  \n403 Reinforcement Learning of Structured Exploration Strategies. In Advances in Neural Informa  \n404 tion Processing Systems, volume 31, pages 5302–5311. Curran Associates, Inc., 2018.   \n405 [21] Jean Harb, Pierre-Luc Bacon, Martin Klissarov, and Doina Precup. When Waiting Is Not an   \n406 Option: Learning Options with a Deliberation Cost. Proceedings of the AAAI Conference on   \n407 Artificial Intelligence, 32(1), 2018.   \n408 [22] Anna Harutyunyan, Will Dabney, Diana Borsa, Nicolas Heess, Remi Munos, and Doina   \n409 Precup. The Termination Critic. In Proceedings of Machine Learning Research, volume 89 of   \n410 Proceedings of Machine Learning Research, pages 2231–2240. PMLR, 2019.   \n411 [23] Maximilian Igl, Andrew Gambardella, Jinke He, Nantas Nardelli, N Siddharth, Wendelin   \n412 Boehmer, and Shimon Whiteson. Multitask Soft Option Learning. In Proceedings of the   \n413 36th Conference on Uncertainty in Artificial Intelligence (UAI), volume 124 of Proceedings of   \n414 Machine Learning Research, pages 969–978. PMLR, 2020.   \n415 [24] George Konidaris and Andrew Barto. Building portable options: Skill transfer in reinforcement   \n416 learning. In Proceedings of the 20th International Joint Conference on Artificial Intelligence,   \n417 pages 895–900, 2007.   \n418 [25] Alexander Li, Carlos Florensa, Ignasi Clavera, and Pieter Abbeel. Sub-policy Adaptation for   \n419 Hierarchical Reinforcement Learning. In International Conference on Learning Representations,   \n420 2020.   \n421 [26] Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-SGD: Learning to Learn Quickly for   \n422 Few Shot Learning. CoRR, abs/1707.09835, 2017.   \n423 [27] Hao Liu, Richard Socher, and Caiming Xiong. Taming MAML: Efficient unbiased meta  \n424 reinforcement learning. In Proceedings of the 36th International Conference on Machine   \n425 Learning, volume 97 of Proceedings of Machine Learning Research, pages 4061–4071. PMLR,   \n426 2019.   \n427 [28] Marlos C. Machado, Marc G. Bellemare, and Michael Bowling. A Laplacian framework for   \n428 option discovery in reinforcement learning. In Proceedings of the 34th International Conference   \n429 on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 2295–   \n430 2304. PMLR, 2017.   \n431 [29] Daniel J Mankowitz, Timothy A Mann, and Shie Mannor. Adaptive skills adaptive partitions   \n432 (asap). In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in   \n433 Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   \n434 [30] Amy McGovern and Andrew G. Barto. Automatic Discovery of Subgoals in Reinforcement   \n435 Learning Using Diverse Density. In Proceedings of the 18th International Conference on   \n436 Machine Learning, ICML ’01, page 361–368, 2001.   \n437 [31] Ishai Menache, Shie Mannor, and Nahum Shimkin. Q-Cut — Dynamic Discovery of Sub-Goals   \n438 in Reinforcement Learning. In Proceedings of the 13th European Conference on Machine   \n439 Learning, ECML’02, page 295–306. Springer-Verlag, 2002.   \n440 [32] Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A Simple Neural Attentive   \n441 Meta-Learner. In International Conference on Learning Representations, 2018.   \n442 [33] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan   \n443 Wierstra, and Martin A. Riedmiller. Playing Atari with Deep Reinforcement Learning. CoRR,   \n444 abs/1312.5602, 2013.   \n445 [34] Ofir Nachum, Shixiang (Shane) Gu, Honglak Lee, and Sergey Levine. Data-Efficient Hierarchi  \n446 cal Reinforcement Learning. In Advances in Neural Information Processing Systems 31, pages   \n447 3303–3313. Curran Associates, Inc., 2018.   \n448 [35] Scott Niekum and Andrew Barto. Clustering via Dirichlet Process Mixture Models for Portable   \n449 Skill Discovery. In Advances in Neural Information Processing Systems, volume 24, pages   \n450 1818–1826. Curran Associates, Inc., 2011.   \n451 [36] Marc Pickett and Andrew G. Barto. Policyblocks: An algorithm for creating useful macro  \n452 actions in reinforcement learning. In Proceedings of the Nineteenth International Conference   \n453 on Machine Learning, pages 506–513. Morgan Kaufmann, 2002.   \n454 [37] Aniruddh Raghu, Maithra Raghu, Samy Bengio, and Oriol Vinyals. Rapid Learning or Feature   \n455 Reuse? Towards Understanding the Effectiveness of MAML. In International Conference on   \n456 Learning Representations, 2020.   \n457 [38] Kate Rakelly, Aurick Zhou, Chelsea Finn, Sergey Levine, and Deirdre Quillen. Efficient Off  \n458 Policy Meta-Reinforcement Learning via Probabilistic Context Variables. In Proceedings of the   \n459 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine   \n460 Learning Research, pages 5331–5340. PMLR, 2019.   \n461 [39] Matthew Riemer, Miao Liu, and Gerald Tesauro. Learning Abstract Options. In Advances in   \n462 Neural Information Processing Systems 31, pages 10424–10434. Curran Associates, Inc., 2018.   \n463 [40] Jonas Rothfuss, Dennis Lee, Ignasi Clavera, Tamim Asfour, and Pieter Abbeel. ProMP: Proximal   \n464 Meta-Policy Search. In International Conference on Learning Representations, 2019.   \n465 [41] John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust   \n466 Region Policy Optimization. In Proceedings of the 32nd International Conference on Machine   \n467 Learning, volume 37 of Proceedings of Machine Learning Research, pages 1889–1897. PMLR,   \n468 2015.   \n469 [42] John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel.   \n470 High-Dimensional Continuous Control Using Generalized Advantage Estimation. CoRR,   \n471 abs/1506.02438, 2015.   \n472 [43] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal   \n473 policy optimization algorithms. CoRR, abs/1707.06347, 2017.   \n474 [44] Matthew Smith, Herke van Hoof, and Joelle Pineau. An Inference-Based Policy Gradient   \n475 Method for Learning Options. In Proceedings of the 35th International Conference on Machine   \n476 Learning, volume 80 of Proceedings of Machine Learning Research, pages 4703–4712. PMLR,   \n477 2018.   \n478 [45] Bradly Stadie, Ge Yang, Rein Houthooft, Peter Chen, Yan Duan, Yuhuai Wu, Pieter Abbeel,   \n479 and Ilya Sutskever. The importance of sampling in meta-reinforcement learning. In Advances   \n480 in Neural Information Processing Systems, volume 31, pages 9280–9290. Curran Associates,   \n481 Inc., 2018.   \n482 [46] Richard S Sutton, Doina Precup, and Satinder Singh. Between MDPs and semi-MDPs: A   \n483 framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):   \n484 181–211, 1999.   \n485 [47] Yee Teh, Victor Bapst, Wojciech M. Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell,   \n486 Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In   \n487 Advances in Neural Information Processing Systems, volume 30, pages 4496–4506. Curran   \n488 Associates, Inc., 2017.   \n489 [48] Sebastian Thrun and Anton Schwartz. Finding structure in reinforcement learning. In G. Tesauro,   \n490 D. Touretzky, and T. Leen, editors, Advances in Neural Information Processing Systems,   \n491 volume 7. MIT Press, 1995.   \n492 [49] E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In 2012   \n493 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 5026–5033, 2012.   \n494 [50] Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg,   \n495 David Silver, and Koray Kavukcuoglu. FeUdal Networks for Hierarchical Reinforcement   \n496 Learning. In Proceedings of the 34th International Conference on Machine Learning, volume 70   \n497 of Proceedings of Machine Learning Research, pages 3540–3549. PMLR, 2017.   \n498 [51] Jane X. Wang, Zeb Kurth-Nelson, Dhruva Tirumala, Hubert Soyer, Joel Z. Leibo, Rémi Munos,   \n499 Charles Blundell, Dharshan Kumaran, and Matthew Botvinick. Learning to reinforcement learn.   \n500 CoRR, abs/1611.05763, 2016.   \n501 [52] Shangtong Zhang and Shimon Whiteson. DAC: The Double Actor-Critic Architecture for   \n502 Learning Options. In Advances in Neural Information Processing Systems, volume 32, pages   \n503 2012–2022. Curran Associates, Inc., 2019.   \n504 [53] Chenyang Zhao, Olivier Sigaud, Freek Stulp, and Timothy M. Hospedales. Investigating   \n505 Generalisation in Continuous Deep Reinforcement Learning. CoRR, abs/1902.07015, 2019.   \n506 [54] Luisa Zintgraf, Kyriacos Shiarli, Vitaly Kurin, Katja Hofmann, and Shimon Whiteson. Fast   \n507 Context Adaptation via Meta-Learning. In Proceedings of the 36th International Conference on   \n508 Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 7693–7702.   \n509 PMLR, 2019. ",
+        "bbox": [
+            137,
+            95,
+            828,
+            877
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            136,
+            70,
+            828,
+            881
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            136,
+            126,
+            828,
+            368
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "510 Checklist ",
+        "text_level": 1,
+        "bbox": [
+            141,
+            391,
+            255,
+            406
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            213,
+            416,
+            341,
+            429
+        ],
+        "page_idx": 12
+    },
+    {
+        "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] See Section 6   \n(c) Did you discuss any potential negative societal impacts of your work? [No] We propose a general meta-reinforcement algorithm that does not have any foreseeable negative social impact   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            434,
+            826,
+            542
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            213,
+            545,
+            494,
+            560
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            563,
+            741,
+            592
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            213,
+            596,
+            393,
+            609
+        ],
+        "page_idx": 12
+    },
+    {
+        "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] In supplemental material   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Some training details are given in Section 5, the rest is provided in Appendix B   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \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] Included in Appendix B ",
+        "bbox": [
+            238,
+            613,
+            826,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            751,
+            823,
+            765
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We cite the codebases and works that introduced environments we use in Section 5   \n(b) Did you mention the license of the assets? [No] We used publicly available code   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We include our codebase in the supplemental material and will make a public github repository   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] We used publicly available code ",
+        "bbox": [
+            238,
+            769,
+            825,
+            878
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We use data from virtual environments ",
+        "bbox": [
+            236,
+            126,
+            828,
+            152
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            213,
+            156,
+            705,
+            170
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            236,
+            173,
+            826,
+            255
+        ],
+        "page_idx": 13
+    }
+]

parse/train/yvQKLaqNE6M/yvQKLaqNE6M.md

@@ -0,0 +1,488 @@
+# YOU ONLY NEED ADVERSARIAL SUPERVISION FOR SEMANTIC IMAGE SYNTHESIS
+
+Edgar Schonfeld¨ ∗ Bosch Center for Artificial Intelligence
+
+Vadim Sushko \* Bosch Center for Artificial Intelligence
+
+Dan Zhang Bosch Center for Artificial Intelligence
+
+Jurgen Gall ¨ University of Bonn
+
+Bernt Schiele Max Planck Institute for Informatics
+
+Anna Khoreva Bosch Center for Artificial Intelligence
+
+# ABSTRACT
+
+Despite their recent successes, GAN models for semantic image synthesis still suffer from poor image quality when trained with only adversarial supervision. Historically, additionally employing the VGG-based perceptual loss has helped to overcome this issue, significantly improving the synthesis quality, but at the same time limiting the progress of GAN models for semantic image synthesis. In this work, we propose a novel, simplified GAN model, which needs only adversarial supervision to achieve high quality results. We re-design the discriminator as a semantic segmentation network, directly using the given semantic label maps as the ground truth for training. By providing stronger supervision to the discriminator as well as to the generator through spatially- and semantically-aware discriminator feedback, we are able to synthesize images of higher fidelity with better alignment to their input label maps, making the use of the perceptual loss superfluous. Moreover, we enable high-quality multi-modal image synthesis through global and local sampling of a 3D noise tensor injected into the generator, which allows complete or partial image change. We show that images synthesized by our model are more diverse and follow the color and texture distributions of real images more closely. We achieve an average improvement of 6 FID and 5 mIoU points over the state of the art across different datasets using only adversarial supervision.
+
+![](images/2332b0bef66597e89b06965264b3f2145c9ae3a3941cd18b8449b8be479a534b.jpg)  
+Figure 1: Existing semantic image synthesis models heavily rely on the VGG-based perceptual loss to improve the quality of generated images. In contrast, our model can synthesize diverse and high-quality images while only using an adversarial loss, without any external supervision.
+
+# 1 INTRODUCTION
+
+Conditional generative adversarial networks (GANs) (Mirza & Osindero, 2014) synthesize images conditioned on class labels (Zhang et al., 2019; Brock et al., 2019), text (Reed et al., 2016; Zhang et al., 2018a), other images (Isola et al., 2017; Huang et al., 2018), or semantic label maps (Wang et al., 2018; Park et al., 2019). In this work, we focus on the latter, addressing semantic image synthesis. Semantic image synthesis enables rendering of realistic images from user-specified layouts, without the use of an intricate graphic engine. Therefore, its applications range widely from content creation and image editing to generating training data that needs to adhere to specific semantic requirements (Wang et al., 2018; Chen & Koltun, 2017). Despite the recent progress on stabilizing GANs (Gulrajani et al., 2017; Miyato et al., 2018; Zhang & Khoreva, 2019) and developing their architectures (Zhang et al., 2019; Karras et al., 2019), state-of-the-art GAN-based semantic image synthesis models (Park et al., 2019; Liu et al., 2019) still greatly suffer from training instabilities and poor image quality when trained only with adversarial supervision (see Fig. 1). An established practice to overcome this issue is to employ a perceptual loss (Wang et al., 2018) to train the generator, in addition to the discriminator loss. The perceptual loss aims to match intermediate features of synthetic and real images, that are estimated via an external perception network. A popular choice for such a network is VGG (Simonyan & Zisserman, 2015), pre-trained on ImageNet (Deng et al., 2009). Although the perceptual loss substantially improves the accuracy of previous methods, it comes with the computational overhead introduced by utilizing an extra network for training. Moreover, it usually dominates over the adversarial loss during training, which can have a negative impact on the diversity and quality of generated images, as we show in our experiments. Therefore, in this work we propose a novel, simplified model that achieves state-of-the-art results without requiring a perceptual loss.
+
+A fundamental question for GAN-based semantic image synthesis models is how to design the discriminator to efficiently utilize information from the given semantic label maps. Conventional methods (Park et al., 2019; Wang et al., 2018; Liu et al., 2019; Isola et al., 2017) adopt a multi-scale classification network, taking the label map as input along with the image, and making a global image-level real/fake decision. Such a discriminator has limited representation power, as it is not incentivized to learn high-fidelity pixel-level details of the images and their precise alignment with the input semantic label maps. To mitigate this issue, we propose an alternative architecture for the discriminator, re-designing it as an encoder-decoder semantic segmentation network (Ronneberger et al., 2015), and directly exploiting the given semantic label maps as ground truth via a $( N { + } 1 )$ -class cross-entropy loss (see Fig. 3). This new discriminator provides semantically-aware pixel-level feedback to the generator, partitioning the image into segments belonging to one of the $N$ real semantic classes or the fake class. Enabled by the discriminator per-pixel response, we further introduce a LabelMix regularization, which fosters the discriminator to focus more on the semantic and structural differences of real and synthetic images. The proposed changes lead to a much stronger discriminator, that maintains a powerful semantic representation of objects, giving more meaningful feedback to the generator, and thus making the perceptual loss supervision superfluous (see Fig. 1).
+
+Next, we propose to enable multi-modal synthesis of the generator via 3D noise sampling. Previously, directly using 1D noise as input was not successful for semantic image synthesis, as the generator tended to mostly ignore it or synthesized images of poor quality (Isola et al., 2017; Wang et al., 2018). Thus, prior work (Wang et al., 2018; Park et al., 2019) resorted to using an image encoder to produce multi-modal outputs. In this work, we propose a lighter solution. Empowered by our stronger discriminator, the generator can effectively synthesize different images by simply re-sampling a 3D noise tensor, which is used not only as the input but also combined with intermediate features via conditional normalization at every layer. Such noise is spatially sensitive, so we can re-sample it both globally (channel-wise) and locally (pixel-wise), allowing to change not only the appearance of the whole scene, but also of specific semantic classes or any chosen areas (see Fig. 2). We call our model OASIS, as it needs only adversarial supervision for semantic image synthesis.
+
+In summary, our main contributions are: (1) We propose a novel segmentation-based discriminator architecture, that gives more powerful feedback to the generator and eliminates the necessity of the perceptual loss supervision. (2) We present a simple 3D noise sampling scheme, notably increasing the diversity of multi-modal synthesis and enabling complete or partial change of the generated image. (3) With the OASIS model, we achieve high quality results on the ADE20K, Cityscapes and COCO-stuff datasets, on average improving the state of the art by 6 FID and 5 mIoU points, while relying only on adversarial supervision. We show that images synthesized by OASIS exhibit much higher diversity and more closely follow the color and texture distributions of real images. Our code and pretrained models are available at https://github.com/boschresearch/OASIS.
+
+![](images/f85a804b034c0634d48d2e3bf2e361e17ac6011c9cc05423ac8bd1db1c390e17.jpg)  
+Figure 2: OASIS multi-modal synthesis results. The 3D noise can be sampled globally (first 2 rows), changing the whole scene, or locally (last 2 rows), partially changing the image. For the latter, we sample different noise per region, like the bed segment (in red) or arbitrary areas defined by shapes.
+
+# 2 RELATED WORK
+
+Semantic image synthesis. Pix2pix (Isola et al., 2017) first proposed to use conditional GANs (Mirza & Osindero, 2014) for semantic image synthesis, adopting an encoder-decoder generator which takes semantic label maps as input, and employing a PatchGAN discriminator. Since then, various generator and discriminator modifications have been introduced (Wang et al., 2018; Park et al., 2019; Liu et al., 2019; Tang et al., 2020c;b; Ntavelis et al., 2020). Besides GANs, Chen & Koltun (2017) proposed to use a cascaded refinement network (CRN) for high-resolution semantic image synthesis, and SIMS (Qi et al., 2018) extended it with a non-parametric component, serving as a memory bank of source material to assist the synthesis. Further, Li et al. (2019) employed implicit maximum likelihood estimation (Li & Malik, 2018) to increase the variety of the CRN model. However, these approaches still underperform in comparison to state-of-the-art GAN models. Therefore, next we focus on the recent GAN architectures for semantic image synthesis.
+
+Discriminator architectures. Pix2pix (Isola et al., 2017), Pix2pixHD (Wang et al., 2018) and SPADE (Park et al., 2019) all employed a multi-scale PatchGAN discriminator, that takes an image and its semantic label map as input. CC-FPSE (Liu et al., 2019) proposed a feature-pyramid discriminator, embedding both images and label maps into a joint feature map, and then consecutively upsampling it in order to classify it as real/fake at multiple scales. LGGAN (Tang et al., 2020c) introduced a classification-based feature learning module to learn more discriminative and class-specific features. In this work, we propose to use a pixel-wise semantic segmentation network as a discriminator instead of multi-scale image classifiers as in the above approaches, and to directly exploit the semantic label maps for its supervision. Segmentation-based discriminators have been shown to improve semantic segmentation (Souly et al., 2017) and unconditional image synthesis (Schonfeld et al., 2020), but to the best of our knowledge have not been explored for semantic image ¨ synthesis and our work is the first to apply adversarial semantic segmentation loss for this task.
+
+Generator architectures. Conventionally, the semantic label map is provided to the image generation pipeline via an encoder (Isola et al., 2017; Wang et al., 2018; Tang et al., 2020c;b; Ntavelis et al., 2020). However, it is shown to be suboptimal at preserving the semantic information until the later stages of image generation. Therefore, SPADE introduced a spatially-adaptive normalization layer that directly modulates the label map onto the generator’s hidden layer outputs at various scales. Alternatively, CC-FPSE proposed to use spatially-varying convolution kernels conditioned on the label map. Struggling with generating diverse images from noise, both Pix2pixHD and SPADE resorted to having an image encoder in the generator design to enable multi-modal synthesis. The generator then combines the extracted image style with the label map to reconstruct the original image. By alternating the style vector, one can generate multiple outputs conditioned on the same label map. However, using an image encoder is a resource demanding solution. In this work, we enable multi-modal synthesis directly through sampling of a 3D noise tensor injected at every layer of the network. Differently from structured noise injection of Alharbi & Wonka (2020) and class-specific latent codes of Zhu et al. (2020), we inject the 3D noise along with label maps and adjust it to image resolution, also enabling re-sampling of selected semantic segments (see Fig. 2).
+
+![](images/385a4d678fa0c4a428fa112d74719636c21375e4d1d975ae6b45b15c542bda65.jpg)  
+Figure 3: SPADE (left) vs. OASIS (right). OASIS outperforms SPADE, while being simpler and lighter: it uses only adversarial loss supervision and a single segmentation-based discriminator, without relying on heavy external networks. Furthermore, OASIS learns to synthesize multi-modal outputs by directly re-sampling the 3D noise tensor, instead of using an image encoder as in SPADE.
+
+Perceptual losses. Gatys et al. (2015); Gatys et al. (2016); Johnson et al. (2016) and Bruna et al. (2016) were pioneers at exploiting perceptual losses to produce high-quality images for superresolution and style transfer using convolutional networks. For semantic image synthesis, the VGGbased perceptual loss was first introduced by CRN, and later adopted by Pix2pixHD. Since then, it has become a default for training the generator (Park et al., 2019; Liu et al., 2019; Tan et al., 2020; Tang et al., 2020a). As the perceptual loss is based on a VGG network pre-trained on ImageNet (Deng et al., 2009), methods relying on it are constrained by the ImageNet domain and the representational power of VGG. With the recent progress on GAN training, e.g. by architecture designs and regularization techniques, the actual necessity of the perceptual loss requires a reassessment. We experimentally show that such loss imposes unnecessary constraints on the generator, significantly limiting sample diversity. While our model, trained without the VGG loss, achieves improved image diversity while not compromising image quality.
+
+# 3 OASIS MODEL
+
+In this section, we present our OASIS model, which, in contrast to other semantic image synthesis methods, needs only adversarial supervision for generator training. Using SPADE as a starting point (Sec. 3.1), we first propose to re-design the discriminator as a semantic segmentation network, directly using the given semantic label maps as ground truth (Sec. 3.2). Empowered by spatiallyand semantically-aware feedback of the new discriminator, we next re-design the SPADE generator, enabling its effective multi-modal synthesis via 3D noise sampling (Sec. 3.3).
+
+# 3.1 THE SPADE BASELINE
+
+We choose SPADE as our baseline as it is a state-of-the-art model and a relatively simple representative of conventional semantic image synthesis models. As depicted in Fig. 3, the discriminator of SPADE largely follows the PatchGAN multi-scale discriminator (Isola et al., 2017), adopting two image classification networks operating at different resolutions. Both of them take the channel-wise concatenation of the semantic label map and the real/synthesized image as input, and produce true/- fake classification scores. On the generator side, SPADE adopts spatially-adaptive normalization layers to effectively integrate the semantic label map into the synthesis process from low to high scales. Additionally, the image encoder is used to extract the style vector from the reference image and then combine it with a 1D noise vector for multi-modal synthesis. The training loss of SPADE consists of three terms, namely, an adversarial loss, a feature matching loss and the VGG-based perceptual loss: $\mathcal { L } = \mathrm { m a x } _ { G } \mathrm { m i n } _ { D } \mathcal { L } _ { \mathrm { a d v } } + \lambda _ { \mathrm { f m } } \mathcal { L } _ { \mathrm { f m } } + \lambda _ { \mathrm { v g g } } \mathcal { L } _ { \mathrm { v g g } }$ . Overall, SPADE is a resource demanding model at both training and test time, i.e., with two PatchGAN discriminators, an image encoder in addition to the generator, and the VGG loss. In the following, we revisit its architecture and introduce a simpler and more efficient model that offers better performance with less complexity.
+
+# 3.2 OASIS DISCRIMINATOR
+
+For the generator to learn to synthesize images that are well aligned with the input semantic label maps, we need a powerful discriminator that coherently captures discriminative semantic features at different image scales. While classification-based discriminators, such as PatchGAN, take label maps as input concatenated to images, they can afford to ignore them and make the decision solely on image patch realism. Thus, we propose to cast the discriminator task as a multi-class semantic segmentation problem to directly utilize label maps for supervision, and accordingly alter its architecture to an encoder-decoder segmentation network (see Fig. 3). Encoder-decoder networks have proven to be effective for semantic segmentation (Badrinarayanan et al., 2016; Chen et al., 2018). Thus, we build our discriminator architecture upon U-Net (Ronneberger et al., 2015), which consists of the encoder and decoder connected by skip connections. This discriminator architecture is multi-scale through its design, integrating information over up- and down-sampling pathways and through the encoder-decoder skip connections. For details on the architecture see App. C.1.
+
+The segmentation task of the discriminator is formulated to predict the per-pixel class label of the real images, using the given semantic label maps as ground truth. In addition to the $N$ semantic classes from the label maps, all pixels of the fake images are categorized as one extra class. Overall, we have $N + 1$ classes in the semantic segmentation problem, and thus propose to use a $( N { + } 1 )$ -class cross-entropy loss for training. Considering that the $N$ semantic classes are usually imbalanced and that the per-pixel size of objects varies for different semantic classes, we weight each class by its inverse per-pixel frequency, giving rare semantic classes more weight. In doing so, the contributions of each semantic class are equally balanced, and, thus, the generator is also encouraged to adequately synthesize less-represented classes. Mathematically, the new discriminator loss is expressed as:
+
+$$
+\begin{array} { r } { \check { \mathcal { L } } _ { D } = - \mathbb { E } _ { ( x , t ) } \left[ \displaystyle \sum _ { c = 1 } ^ { N } \alpha _ { c } \sum _ { i , j } ^ { H \times W } t _ { i , j , c } \log D ( x ) _ { i , j , c } \right] ^ { \sim } - \mathbb { E } _ { ( z , t ) } \left[ \sum _ { i , j } ^ { H \times W } \log D ( G ( z , t ) ) _ { i , j , c = N + 1 } \right] , } \end{array}
+$$
+
+where $x$ denotes the real image; $( z , t )$ is the noise-label map pair used by the generator $G$ to synthesize a fake image; and the discriminator $D$ maps the real or fake image into a per-pixel $( N { + } 1 )$ -class prediction probability. The ground truth label map $t$ has three dimensions, where the first two correspond to the spatial position $( i , j ) \in H \times W$ , and the third one is a one-hot vector encoding the class $c \in \{ 1 , . . , N { + } 1 \}$ . The class balancing weight $\alpha _ { c }$ is the inverse of the per-pixel class frequency
+
+$$
+\alpha _ { c } = \frac { \mathbf { \bar { \alpha } } _ { H } \times W } { \sum _ { i , j } ^ { H \times W } E _ { t } \left[ \mathbb { 1 } \left[ t _ { i , j , c } = 1 \right] \right] } .
+$$
+
+LabelMix regularization. In order to encourage our discriminator to focus on differences in content and structure between the fake and the real classes, we propose a LabelMix regularization. Based on the semantic layout, we generate a binary mask $M$ to mix a pair $( x , { \hat { x } } )$ of real and fake images conditioned on the same label map: Labe $\operatorname { M i x } ( x , { \hat { x } } , M ) = M \odot x + ( 1 - M ) \odot { \hat { x } }$ , as visualized in Fig. 4. Given the mixed image, we further train the discriminator to be equivariant under the LabelMix operation. This is achieved by adding a consistency loss term $\mathcal { L } _ { c o n s }$ to Eq. 1:
+
+$$
+\mathcal { L } _ { c o n s } = \Big \| D _ { \mathrm { l o g i t s } } \Big ( \mathrm { L a b e l M i x } ( x , \hat { x } , M ) \Big ) - \mathrm { L a b e l M i x } \Big ( D _ { \mathrm { l o g i t s } } ( x ) , D _ { \mathrm { l o g i t s } } ( \hat { x } ) , M \Big ) \Big \| ^ { 2 } .
+$$
+
+where $D _ { \mathrm { l o g i t s } }$ are the logits attained before the last softmax activation layer, and $\| \cdot \|$ is the $L _ { 2 }$ norm. This consistency loss compares the output of the discriminator on the LabelMix image with the LabelMix of its outputs, penalizing the discriminator for inconsistent predictions. LabelMix is different to CutMix (Yun et al., 2019), which randomly samples the binary mask $M$ . A random mask will introduce inconsistency between the pixel-level classes and the scene layout provided by the label map. For an object with the semantic class $c$ , it will contain pixels from both real and fake images, resulting in two labels, i.e. $c$ and $N + 1$ . To avoid such inconsistency, the mask of LabelMix is generated according to the label map, providing natural borders between semantic regions, see Fig. 4 (Mask $M _ { ☉ }$ ). Under LabelMix regularization, the generator is encouraged to respect the natural semantic boundaries, improving pixel-level realism while also considering the class segment shapes.
+
+![](images/acdaa975c36b331a887c5af8984d7c5593a8d8e548e00830fc806c0a082277c2.jpg)  
+Figure 4: LabelMix regularization. Real $x$ and fake $\hat { x }$ images are mixed using a binary mask $M$ , sampled based on the label map, resulting in La $\mathrm { \ u b e l M i x } _ { ( x , \hat { x } ) }$ . The consistency regularization then minimizes the L2 distance between the logits of DLabelMix(x,xˆ) and LabelMix $( D _ { x } , D _ { \hat { x } } )$ . In this visualization, black corresponds to the fake class in the $N { + 1 }$ segmentation output.
+
+Other variants. Besides the proposed $( N { + } 1 )$ -class cross entropy loss, there are other ways to train the segmentation-based discriminator with the label map. One can concatenate the label map to the input image, analogous to SPADE. Another option is to use projection, by taking the inner product between the last linear layer output and the embedded label map, analogous to class-label conditional GANs (Miyato & Koyama, 2018). For both alternatives, the training loss is pixel-level real/fake binary cross-entropy (Schonfeld et al., 2020). From the label map encoding perspective, ¨ these two variants use labels map as input (concatenated to image or at last linear layer), propagating it forward through the network. The $( N { + } 1 )$ -setting uses the label map for loss computation, so it is propagated backward via gradient updates. Backward propagation ensures that the discriminator learns semantic-aware features, in contrast to forward propagation, where the label map alignment is not as strongly enforced. Performance comparison of the label map encodings is shown in Table 5.
+
+# 3.3 OASIS GENERATOR
+
+To stay in line with the OASIS discriminator design, the training loss for the generator is changed to
+
+$$
+\mathcal { L } _ { G } = - \mathbb { E } _ { ( z , t ) } \left[ \sum _ { c = 1 } ^ { N } \alpha _ { c } \sum _ { i , j } ^ { H \times \bar { W } } t _ { i , j , c } \log D ( G ( z , t ) ) _ { i , j , c } \right] ^ { - } ,
+$$
+
+which is a direct outcome of the non-saturation trick (Goodfellow et al., 2014) to Eq. 1. We next re-design the generator to enable multi-modal synthesis through noise sampling. SPADE is deterministic in its default setup, but can be trained with an extra image encoder to generate multi-modal outputs. We introduce a simpler version, that enables synthesis of diverse outputs directly from input noise. For this, we construct a noise tensor of size $6 4 \times H \times W$ , matching the spatial dimensions of the label map $H \times W$ . Channel-wise concatenation of the noise and label map forms a 3D tensor used as input to the generator and also as a conditioning at every spatially-adaptive normalization layer. In doing so, intermediate feature maps are conditioned on both the semantic labels and the noise (see Fig. 3). With such a design, the generator produces diverse, noise-dependent images. As the 3D noise is channel- and pixel-wise sensitive, at test time, one can sample the noise globally, per-channel, and locally, per-segment or per-pixel, for controlled synthesis of the whole scene or of specific semantic objects. For example, when generating a scene of a bedroom, one can re-sample the noise locally and change the appearance of the bed alone (see Fig. 2). Note that for simplicity during training we sample the 3D noise tensor globally, i.e. per-channel, replicating each channel value spatially along the height and width of the tensor. We analyse alternative ways of sampling 3D noise during training in App. A.7. Using image styles via an encoder, as in SPADE, is also possible in our setting, by replacing noise with encoder features. Lastly, to further reduce the complexity, we remove the first residual block in the generator, reducing the number of parameters from 96M to 72M (see App. C.2) without a noticeable performance loss (see Table 3).
+
+![](images/357ef04e8b4f1473b1eefaadd27c06e2e8f13f75285d5facbfe6fdf4ae0ca490.jpg)  
+Figure 5: Qualitative comparison of OASIS with other methods on ADE20K. Trained with only adversarial supervision, our model generates images with better perceptual quality and structure.
+
+# 4 EXPERIMENTS
+
+We conduct experiments on three challenging datasets: ADE20K (Zhou et al., 2017), COCO-stuff (Caesar et al., 2018) and Cityscapes (Cordts et al., 2016). Following Qi et al. (2018), we also evaluate OASIS on ADE20K-outdoors, a subset of ADE20K containing outdoor scenes. We follow the experimental setting of Park et al. (2019). We did not use the GAN feature matching loss for OASIS, as we did not observe any improvement with it (see App. A.5), and used the VGG loss only for ablations with $\lambda _ { \mathrm { V G G } } = 1 0$ . We did not experience any training instabilities and, thus, did not employ any extra stabilization techniques. All our models use an exponential moving average (EMA) of the generator weights with 0.9999 decay. For further training details refer to App. C.3.
+
+Following prior work (Isola et al., 2017; Wang et al., 2018; Park et al., 2019; Liu et al., 2019), we evaluate models quantitatively on the validation set using the Frechet Inception Distance (FID) ´ (Heusel et al., 2017) and mean Intersection-over-Union (mIoU). FID is known to be sensitive to both quality and diversity and has been shown to be well aligned with human judgement (Heusel et al., 2017). We show additional evaluation of quality and diversity with ”improved precision and recall” in App. A.9. Mean IoU is used to assess the alignment of the generated image with the ground truth label map, computed via a pre-trained semantic segmentation network. We use UperNet101 (Xiao et al., 2018) for ADE20K, multi-scale DRN-D-105 (Yu et al., 2017) for Cityscapes, and DeepLabV2 (Chen et al., 2015) for COCO-Stuff. We additionally propose to compare color and texture statistics between generated and real images on ADE20K to better understand how the perceptual loss influences performance. For this, we compute color histograms in LAB space and measure the earth mover’s distance between the real and generated sets (Rubner et al., 2000). We measure the texture similarity to the real data as the $\chi ^ { 2 }$ -distance between Local Binary Patterns histograms (Ojala et al., 1996). As different classes have different color and texture distributions, we aggregate histogram distances separately per class and then take the mean. Lower values for the texture and color distances indicate a closer similarity to real data.
+
+# 4.1 MAIN RESULTS
+
+We use SPADE as our baseline, using the authors’ implementation1. For a fair comparison, we train this model without the feature matching loss and using EMA (Yaz et al., 2018) at test phase, which we further refer to as $\mathrm { S P A D E + }$ . We found that the feature matching loss has a negligible impact (see App. A.5), while EMA significantly increases the performance for all metrics (see Table 1).
+
+Table 1: Comparison with other methods across datasets.Bold denotes the best performance.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2"># param</td><td rowspan="2">VGG</td><td colspan="2">ADE20K mIoU个</td><td colspan="2">ADE-outd.</td><td colspan="2">Cityscapes</td><td colspan="2">COCO-stuff</td></tr><tr><td>FID↓</td><td></td><td>FID↓</td><td>mIoU↑</td><td>FID↓</td><td>mIoU个</td><td>FID↓</td><td>mIoU↑</td></tr><tr><td>CRN SIMS</td><td>84M</td><td></td><td>73.3</td><td>22.4</td><td>99.0</td><td>16.5</td><td>104.7</td><td>52.4</td><td>70.4</td><td>23.7</td></tr><tr><td></td><td>56M</td><td></td><td>n/a</td><td>n/a</td><td>67.7</td><td>13.1</td><td>49.7</td><td>47.2</td><td>n/a</td><td>n/a</td></tr><tr><td>Pix2pixHD</td><td>183M</td><td></td><td>81.8</td><td>20.3</td><td>97.8</td><td>17.4</td><td>95.0</td><td>58.3</td><td>111.5</td><td>14.6</td></tr><tr><td>LGGAN CC-FPSE</td><td>n/a</td><td></td><td>31.6</td><td>41.6</td><td>n/a</td><td>n/a</td><td>57.7</td><td>68.4</td><td>n/a</td><td>n/a</td></tr><tr><td>SPADE</td><td>131M</td><td>：</td><td>31.7</td><td>43.7</td><td>n/a</td><td>n/a</td><td>54.3</td><td>65.5</td><td>19.2</td><td>41.6</td></tr><tr><td></td><td>102M</td><td></td><td>33.9 32.9</td><td>38.5</td><td>63.3</td><td>30.8</td><td>71.8</td><td>62.3</td><td>22.6</td><td>37.4</td></tr><tr><td rowspan="2">SPADE+ OASIS</td><td>102M</td><td>√</td><td>60.7</td><td>42.5</td><td>51.1</td><td>32.1</td><td>47.8</td><td>64.0</td><td>21.7</td><td>38.8</td></tr><tr><td>94M</td><td>× ×</td><td>28.3</td><td>21.0 48.8</td><td>65.4 48.6</td><td>22.7 40.4</td><td>61.4 47.7</td><td>47.6 69.3</td><td>99.1 17.0</td><td>16.1 44.1</td></tr></table>
+
+Table 2: Multi-modal synthesis evaluation on ADE20K. Bold and red denote the best and the worst performance, respectively.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Method |Multi-mod.</td><td rowspan=1 colspan=1>VGG</td><td rowspan=1 colspan=2>MS-SSIM↓</td><td rowspan=1 colspan=2>MS-SSIM↓</td><td rowspan=1 colspan=1>LPIPS↑</td><td rowspan=1 colspan=1>FID↓</td></tr><tr><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>Encoder</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=3>0.85</td><td rowspan=1 colspan=1>0.16</td><td rowspan=1 colspan=1>33.4</td><td rowspan=1 colspan=1>40.2</td></tr><tr><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>3D noise</td><td rowspan=1 colspan=1>x√</td><td rowspan=1 colspan=3>0.350.53</td><td rowspan=1 colspan=1>0.500.36</td><td rowspan=1 colspan=1>58.434.4</td><td rowspan=1 colspan=1>18.736.2</td></tr><tr><td rowspan=1 colspan=1>OASIS</td><td rowspan=1 colspan=1>3D noise</td><td rowspan=1 colspan=1>×√</td><td rowspan=1 colspan=3>0.650.88</td><td rowspan=1 colspan=1>0.350.15</td><td rowspan=1 colspan=1>28.331.6</td><td rowspan=1 colspan=1>48.850.8</td></tr></table>
+
+![](images/481520490c5ebd46092d8ba75ff4b732a1ae965c398c1a5042d01a233be0a3d2.jpg)  
+Figure 6: Histogram distances to real data.
+
+OASIS outperforms the current state of the art on all datasets with an average improvement of 6 FID and 5 mIoU points (Table 1). Importantly, OASIS achieved the improvement via adversarial supervision alone. On the contrary, SPADE $^ +$ does not produce images of high visual quality without the perceptual loss, and struggles to learn the color and texture distribution of real images (Fig. 6). A strong discriminator is the key factor for good performance: without a rich training signal from the discriminator, the $\mathrm { S P A D E + }$ generator has to learn through minimizing the VGG loss. With the stronger OASIS discriminator, the perceptual loss does not overtake the generator supervision (see App. A.2), allowing to produce images with the color and texture distribution closer to the real data.
+
+Fig. 5 shows a qualitative comparison of our results to previous models. Our approach noticeably improves image quality, synthesizing finer textures and more natural colors. With the powerful feedback from the discriminator, OASIS is able to learn the appearance of small or rarely occurring semantic classes (which is reflected in the per-class IoU scores presented in App. A.3), producing plausible results even for complex scenes with rare classes and reducing unnatural artifacts.
+
+Multi-modal image synthesis. In contrast to previous work, OASIS can produce diverse images by directly re-sampling input 3D noise. As 3D noise modulates features directly at every layer of the generator at different scales, matching their resolution, it affects both global and local characteristics of the image. Thus, the noise can be sampled globally, varying the whole image, or locally, resulting in the selected object change while preserving the rest of the scene (see Fig. 2).
+
+To measure the variation in the multi-modal generation, we evaluate MS-SSIM (Wang et al., 2003) and LPIPS (Zhang et al., 2018b) between images generated from the same label map. We generate 20 images and compute the mean pairwise scores, and then average over all label maps. The lower the MS-SSIM and the higher the LPIPS scores, the more diverse the generated images are. To assess the effect of the perceptual loss and the noise sampling on diversity, we train $\mathrm { S P A D E + }$ with 3D noise or the image encoder, and with or without the perceptual loss. Table 2 shows that OASIS, without perceptual loss, improves over $\mathrm { S P A D E + }$ with the image encoder, both in terms of image diversity (MS-SSIM, LPIPS) and quality (mean FID, mIoU across 20 realizations). Using 3D noise further increases diversity for $\mathrm { S P A D E + }$ . However, a strong quality-diversity tradeoff exists for $\mathrm { S P A D E + }$ : 3D noise improves diversity at the cost of quality, and the perceptual loss improves quality at the cost of diversity. For OASIS, the VGG loss also reduces diversity but does not noticeably affect quality. Note that in our experiments LabelMix does not notably affect diversity (see App. A.1).
+
+# 4.2 ABLATIONS
+
+We conduct ablations on ADE20K to evaluate our proposed changes. The main ablation shows the impact of our new discriminator, lighter generator, LabelMix and 3D noise. Further ablations are concerned with architecture changes and the label map encodings in the discriminator, where for fair comparison we use no 3D noise and LabelMix.
+
+Main ablation. Table 3 shows that $\mathrm { S P A D E + }$ scores low on the image quality metrics without the perceptual loss. Replacing the $\mathrm { S P A D E + }$ discriminator with the OASIS discriminator, while keeping the generator fixed, improves FID and mIoU by more than 30 points. Changing the $\mathrm { S P A D E + }$ generator to the lighter OASIS generator leads to a negligible degradation of 0.3 in FID and 0.5 in mIoU. With LabelMix FID improves further by $\sim 1$ point (more ablations on LabelMix in App. A.4). Adding 3D noise improves FID but degrades mIoU, as diversity complicates the task of the pre-trained semantic segmentation network used to compute the score. For OASIS the perceptual loss deteriorates FID by more than 2 points, but improves mIoU. Overall, without the perceptual loss the new discriminator is the key to the performance boost over $\mathrm { S P A D E + }$ .
+
+Table 3: OASIS ablation on ADE20K. Bold denotes the best performance.   
+
+<table><tr><td rowspan=1 colspan=1>G</td><td rowspan=1 colspan=1>D</td><td rowspan=1 colspan=1>VGG</td><td rowspan=1 colspan=1>LabelMix|</td><td rowspan=1 colspan=1>FID↓mIoU↑</td></tr><tr><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>60.7 21.0</td></tr><tr><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>OASIS</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>29.0 52.1</td></tr><tr><td rowspan=1 colspan=1>OASIS</td><td rowspan=1 colspan=1>OASIS</td><td rowspan=1 colspan=1>X×</td><td rowspan=1 colspan=1>×√</td><td rowspan=1 colspan=1>29.3 51.628.4 50.6</td></tr><tr><td rowspan=1 colspan=1>OASIS+3D noise</td><td rowspan=1 colspan=1>OASIS</td><td rowspan=1 colspan=1>X【</td><td rowspan=1 colspan=1>【</td><td rowspan=1 colspan=1>28.3 48.831.6 50.8</td></tr></table>
+
+Ablation on the discriminator architecture. We train the OASIS generator with three alternative discriminators: the original multi-scale PatchGAN consisting of two networks, a single-scale PatchGAN, and a ResNet-based discriminator, corresponding to the encoder of the U-Net shaped OASIS discriminator. Table 4 shows that the alternative discriminators only perform well with perceptual supervision, while the OASIS discriminator achieves superior performance independent of it. The single-scale
+
+Table 4: Ablation on the $D$ architecture. Bold denotes the best performance, red highlights collapsed runs.   
+
+<table><tr><td>D architecture</td><td>w/o VGG FID↓ mIoU↑</td><td>with VGG FID↓ mIoU↑</td></tr><tr><td>MS-PatchGAN (2x)</td><td>60.7 21.0</td><td>32.9 42.5</td></tr><tr><td>PatchGAN</td><td>197 0.62</td><td>34.2 42.2</td></tr><tr><td>ResNet-PatchGAN</td><td>147 0.42</td><td>32.4 45.1</td></tr><tr><td>OASIS</td><td>29.3 51.6</td><td>29.2 51.1</td></tr></table>
+
+discriminators even collapse without the perceptual loss (highlighted in red in Table 4).
+
+Ablation on the label map encoding. We study four different label map encodings: input concatenation, as in SPADE, projection conditioned on the label map (Miyato & Koyama, 2018), employing label maps as ground truth for the $N { + 1 }$ segmentation loss, or for the class-balanced $N { + 1 }$ loss (see Sec. 3.2). As shown in Table 5, input concatenation is not sufficient without additional perceptual loss supervision, leading to training collapse. Without perceptual loss, the $N { + 1 }$ loss outperforms the input concatenation and the projection in both the FID and mIoU metrics. The class balancing noticeably improves mIoU due to better supervision for rarely occurring semantic classes. More ablations can be found in App. A.
+
+Table 5: Ablation on the label map encoding. Bold denotes the best performance, red highlights collapsed runs.   
+
+<table><tr><td>Label encoding</td><td>w/o VGG FID↓ mIoU↑</td><td>with VGG FID↓ mIoU↑</td></tr><tr><td>Input concatenation</td><td>280 0.02</td><td>30.0 43.9</td></tr><tr><td>Projection</td><td>32.4 44.9</td><td>28.0 46.9</td></tr><tr><td>N+1 loss</td><td>28.3 47.2</td><td>28.6 49.8</td></tr><tr><td>Balanced N+1 loss</td><td>29.3 51.6</td><td>29.2 51.1</td></tr></table>
+
+# 5 CONCLUSION
+
+In this work we propose OASIS, a semantic image synthesis model that only relies on adversarial supervision to achieve high fidelity image synthesis. In contrast to previous work, our model eliminates the need for a perceptual loss, which often imposes extra constraints on image quality and diversity. This is achieved via detailed spatial and semantic-aware supervision from our novel segmentation-based discriminator, which uses semantic label maps as ground truth for training. With this powerful discriminator, OASIS can easily generate diverse multi-modal outputs by re-sampling the 3D noise, both globally and locally, allowing to change the appearance of the whole scene and of individual objects. OASIS significantly improves over the state of the art in terms of image quality and diversity, while being simpler and more lightweight than previous methods.
+
+# ACKNOWLEDGEMENT
+
+Jurgen Gall has been supported by the Deutsche Forschungsgemeinschaft (DFG, German Research¨ Foundation) under Germany’s Excellence Strategy - EXC 2070 -390732324.
+
+# REFERENCES
+
+Yazeed Alharbi and Peter Wonka. Disentangled image generation through structured noise injection. In Conference on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+Vijay Badrinarayanan, Alex Kendall, and Roberto Cipolla. Segnet: A deep convolutional encoderdecoder architecture for image segmentation. Transactions on Pattern Analysis and Machine Intelligence, 2016.
+
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image synthesis. In International Conference on Learning Representations (ICLR), 2019.
+
+Joan Bruna, Pablo Sprechmann, and Yann LeCun. Super-resolution with deep convolutional sufficient statistics. In International Conference on Learning Representations (ICLR), 2016.
+
+Holger Caesar, Jasper Uijlings, and Vittorio Ferrari. Coco-stuff: Thing and stuff classes in context. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Semantic image segmentation with deep convolutional nets and fully connected crfs. International Conference on Learning Representations (ICLR), 2015.
+
+Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam. Encoderdecoder with atrous separable convolution for semantic image segmentation. In European Conference on Computer Vision (ECCV), 2018.
+
+Qifeng Chen and Vladlen Koltun. Photographic image synthesis with cascaded refinement networks. In International Conference on Computer Vision (ICCV), 2017.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In Conference on Computer Vision and Pattern Recognition (CVPR), 2009.
+
+L. A. Gatys, A. S. Ecker, and M. Bethge. Image style transfer using convolutional neural networks. In Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Leon Gatys, Alexander S Ecker, and Matthias Bethge. Texture synthesis using convolutional neural networks. In Advances in Neural Information Processing Systems (NeurIPs). 2015.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems (NeurIPS), 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of Wasserstein GANs. In Advances in Neural Information Processing Systems (NeurIPS), 2017.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems (NeurIPS), 2017.
+
+Xun Huang, Ming-Yu Liu, Serge Belongie, and Jan Kautz. Multimodal unsupervised image-toimage translation. In European Conference on Computer Vision (ECCV), 2018.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European Conference on Computer Vision (ECCV), 2016.
+
+Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015.
+
+Tuomas Kynka¨anniemi, Tero Karras, Samuli Laine, Jaakko Lehtinen, and Timo Aila. Improved ¨ precision and recall metric for assessing generative models. In Advances in Neural Information Processing Systems, pp. 3927–3936, 2019.
+
+Ke Li and Jitendra Malik. Implicit maximum likelihood estimation. arXiv preprint arXiv:1809.09087, 2018.
+
+Ke Li, Tianhao Zhang, and Jitendra Malik. Diverse image synthesis from semantic layouts via conditional imle. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4220–4229, 2019.
+
+Xihui Liu, Guojun Yin, Jing Shao, Xiaogang Wang, et al. Learning to predict layout-to-image conditional convolutions for semantic image synthesis. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv:1411.1784, 2014.
+
+Takeru Miyato and Masanori Koyama. cGANs with projection discriminator. In International Conference on Learning Representations (ICLR), 2018.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In International Conference on Learning Representations (ICLR), 2018.
+
+Evangelos Ntavelis, Andres Romero, Iason Kastanis, Luc Van Gool, and Radu Timofte. Sesame: ´ Semantic editing of scenes by adding, manipulating or erasing objects. arXiv:2004.04977, 2020.
+
+Timo Ojala, Matti Pietikainen, and David Harwood. A comparative study of texture measures with ¨ classification based on featured distributions. Pattern recognition, 29(1):51–59, 1996.
+
+Taesung Park, Ming-Yu Liu, Ting-Chun Wang, and Jun-Yan Zhu. Semantic image synthesis with spatially-adaptive normalization. In Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Xiaojuan Qi, Qifeng Chen, Jiaya Jia, and Vladlen Koltun. Semi-parametric image synthesis. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Suman Ravuri and Oriol Vinyals. Classification accuracy score for conditional generative models. In Advances in Neural Information Processing Systems, pp. 12268–12279, 2019.
+
+Scott E. Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. In International Conference on Machine learning (ICML), 2016.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In MICCAI, 2015.
+
+Yossi Rubner, Carlo Tomasi, and Leonidas J Guibas. The earth mover’s distance as a metric for image retrieval. International Journal of Computer Vision (IJCV), 2000.
+
+Mehdi SM Sajjadi, Olivier Bachem, Mario Lucic, Olivier Bousquet, and Sylvain Gelly. Assessing generative models via precision and recall. In Advances in Neural Information Processing Systems, pp. 5228–5237, 2018.
+
+Edgar Schonfeld, Bernt Schiele, and Anna Khoreva. A u-net based discriminator for generative ¨ adversarial networks. In Conference on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+Konstantin Shmelkov, Cordelia Schmid, and Karteek Alahari. How good is my gan? In Proceedings of the European Conference on Computer Vision (ECCV), pp. 213–229, 2018.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR), 2015.
+
+Nasim Souly, Concetto Spampinato, and Mubarak Shah. Semi supervised semantic segmentation using generative adversarial network. In International Conference on Computer Vision (ICCV), 2017.
+
+Zhentao Tan, Dongdong Chen, Qi Chu, Menglei Chai, Jing Liao, Mingming He, Lu Yuan, and Nenghai Yu. Rethinking spatially-adaptive normalization. arXiv:2004.02867, 2020.
+
+Hao Tang, Song Bai, and Nicu Sebe. Dual attention gans for semantic image synthesis. In Proceedings of the 28th ACM International Conference on Multimedia, pp. 1994–2002, 2020a.
+
+Hao Tang, Xiaojuan Qi, Dan Xu, Philip HS Torr, and Nicu Sebe. Edge guided gans with semantic preserving for semantic image synthesis. arXiv:2003.13898, 2020b.
+
+Hao Tang, Dan Xu, Yan Yan, Philip HS Torr, and Nicu Sebe. Local class-specific and global imagelevel generative adversarial networks for semantic-guided scene generation. In Conference on Computer Vision and Pattern Recognition (CVPR), 2020c.
+
+Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, Andrew Tao, Jan Kautz, and Bryan Catanzaro. Highresolution image synthesis and semantic manipulation with conditional GANs. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In Asilomar Conference on Signals, Systems & Computers, 2003.
+
+Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang, and Jian Sun. Unified perceptual parsing for scene understanding. In European Conference on Computer Vision (ECCV), 2018.
+
+Yasin Yaz, Chuan-Sheng Foo, Stefan Winkler, Kim-Hui Yap, Georgios Piliouras, Vijay Chandrasekhar, et al. The unusual effectiveness of averaging in gan training. In International Conference on Learning Representations, 2018.
+
+Fisher Yu, Vladlen Koltun, and Thomas Funkhouser. Dilated residual networks. In Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In International Conference on Computer Vision (ICCV), 2019.
+
+Dan Zhang and Anna Khoreva. PA-GAN: Improving GAN training by progressive augmentation. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+H. Zhang, T. Xu, H. Li, S. Zhang, X. Wang, X. Huang, and D. N. Metaxas. StackGAN $^ { + + }$ : Realistic image synthesis with stacked generative adversarial networks. Transactions on Pattern Analysis and Machine Intelligence, 2018a.
+
+Han Zhang, Ian J. Goodfellow, Dimitris N. Metaxas, and Augustus Odena. Self-attention generative adversarial networks. In International Conference on Machine learning (ICML), 2019.
+
+Hang Zhang, Chongruo Wu, Zhongyue Zhang, Yi Zhu, Zhi Zhang, Haibin Lin, Yue Sun, Tong He, Jonas Mueller, R Manmatha, et al. Resnest: Split-attention networks. arXiv preprint arXiv:2004.08955, 2020.
+
+Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018b.
+
+Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Scene parsing through ade20k dataset. In Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Zhen Zhu, Zhiliang Xu, Ansheng You, and Xiang Bai. Semantically multi-modal image synthesis. In Conference on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+# APPENDIX
+
+This supplementary material to the main paper is structured as follows:
+
+A Additional quantitative results.
+
+A.1 Main ablation study on two datasets. A.2 The influence of the perceptual loss on training dynamics. A.3 Per-class IoU scores across different datasets. A.4 Comparing LabelMix and CutMix for consistency regularization. A.5 Ablation on the Feature Matching loss. A.6 Ablation on using multiple OASIS discriminators. A.7 Ablation on noise sampling strategies during training. A.8 Additional experiments on COCO-stuff. A.9Additional image quality metrics. B: Additional qualitative results. B.1 Visual comparison of OASIS to other works. B.2 Multi-modal synthesis results for different label maps. B.3 Interpolations between multi-modal images in latent space. B.4 Application to unlabelled data. B.5 Additional visual LabelMix examples.
+
+C: A detailed description of the OASIS architecture and its training details. C.1 Discriminator architecture. C.2 Generator architecture. C.3 Learning objective and training details.
+
+A QUANTITATIVE RESULTS
+
+# A.1 SUMMARIZED MAIN ABLATION OVER TWO DATASETS
+
+Table A: Summarized ablation on two datasets. Bold denotes the best performance. Red denotes the worst performance among experiments with 3D noise. Green denotes the major performance gains that are caused by the proposed OASIS discriminator and LabelMix.
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">Cityscapes</td><td colspan="2">ADE20K</td></tr><tr><td>FID↓</td><td>mIoU↑</td><td>MS-SSIM↓</td><td>FID↓ mIoU↑</td><td>MS-SSIM↓</td></tr><tr><td>SPADE+</td><td>61.4</td><td>47.6</td><td>1.0</td><td>60.7</td><td>21.0 1.0</td></tr><tr><td>+ OASIS D, G</td><td>54.1</td><td>67.6</td><td>1.0</td><td>29.3 51.6</td><td>1.0</td></tr><tr><td>+ 3D noise</td><td>51.5</td><td>66.3</td><td>0.62</td><td>28.9 47.3</td><td>0.63</td></tr><tr><td>+ LabelMix</td><td>47.7</td><td>69.3</td><td>0.64</td><td>28.3 48.8</td><td>0.65</td></tr><tr><td>+ VGG</td><td>46.1</td><td>72.0</td><td>0.84</td><td>31.6 50.8</td><td>0.88</td></tr></table>
+
+In Table A we present a summarized version of our ablations for the ADE20K and Cityscapes dataset. The following observations can be made:
+
+(1) Looking at the 2nd row of Table A, we see that the main performance gain comes from the discriminator design (major) (OASIS D,G). The OASIS generator is a lighter version of the SPADE generator, which does not result in a performance improvement (Table 3), but has significantly less parameters. A second source of improvement is LabelMix.
+
+(2) The mIoU can drop when 3D noise is added, as diversity complicates the task of the pre-trained semantic segmentation network that is used to compute the mIoU score. Note that the purpose of noise is not to improve the image quality (FID) but to improve diversity (MS-SSIM).
+
+(3) The perceptual loss can hurt performance and diversity by biasing the generator towards ImageNet, as in this case the target distribution is more difficult to recreate fully. By punishing diversity, the perceptual loss encourages generating images with more standard semantic features This facilitates the task of external pretrained segmenters, and consequently helps to raise the mIoU metric.
+
+# A.2 THE INFLUENCE OF VGG ON TRAINING DYNAMICS
+
+Table 1 and Figure 1 illustrate that performance of $\mathrm { S P A D E + }$ strongly depends on the perceptual loss. In contrast, OASIS achieves high quality without this loss (Table 1). We find the explanation in the fact, that the $\mathrm { S P A D E + }$ Patch-GAN discriminator does not provide a strong training signal for the generator. At the absence of strong supervision from the discriminator, the generator resorts to learning mostly from the VGG loss. The loss curves in Fig. A support this finding: throughout the training the $\mathrm { S P A D E + }$ model focuses on minimizing the VGG loss, keeping the adversarial generator loss more or less constant. In contrast, OASIS significantly improves adversarial generator loss during training, learning to fool the segmentation-based OASIS discriminator. That indicates a better adversarial balance, when the generator learns semantically meaningful features that the segmenter judges as real. The difference in scales of G loss for models comes from different objectives, since SPADE $^ +$ optimizes binary cross entropy, and OASIS minimizes multi-class cross entropy with $N { + 1 }$ classes.
+
+![](images/69b897b915e893b733765d9635c905143dfe176e9884abeaffe561080b77f49c.jpg)  
+Figure A: VGG and adversarial G losses for SPADE and OASIS, trained with the perceptual loss
+
+# A.3 PER-CLASS IOU SCORES
+
+As seen in Table 1 in the main paper, OASIS significantly outperforms previous approaches in mIoU. We found that the improvement comes mainly from the better IoU scores achieved for lessrepresented semantic classes. To illustrate the gain, we report per-class IoU scores on ADE20k, COCO-Stuff and Cityscapes in Tables B, C and D. For visualization purposes, we sorted the semantic classes of all datasets, ordering by their pixel-wise frequency in the training images.
+
+Taking ADE20k as an example, Table B highlights that the relative gain in mIoU is especially high for the group of less-represented semantic classes, that cover less than $3 \%$ of all the images. For these rare classes the relative gain over the baseline exceeds $4 0 \%$ . We found that the gain majorly comes from the per-class balancing applied in the OASIS loss function. In order to illustrate this effect, we train OASIS without the proposed balancing. Table B reveals, this baseline reaches a bit higher score for frequent classes, but shows worse performance for the rarely occurring ones. This is expected, as the balancing down-weights the objects met frequently while up-weights infrequent classes. We thus conclude that the balancing draws the attention of the discriminator to rarely occurring semantic classes, which results in a much higher quality of the generation.
+
+# A.4 ABLATION ON LABELMIX
+
+Consistency regularization for the segmentation output of the discriminator requires a method of generating binary masks. Therefore, we compare the effectiveness of CutMix (Yun et al., 2019) and our proposed LabelMix. Both methods produce binary masks, but only LabelMix respects the boundaries between semantic classes in the label map. Table E compares the FID and mIoU scores of OASIS trained with both methods on the Cityscapes dataset. It can be seen that LabelMix improves both FID (51.5 vs. 47.7) and mIoU (66.3 vs. 69.3), in comparison to OASIS without consistency regularization. CutMix-based consistency regularization only improves the mIoU (66.3 vs. 67.4),
+
+Table B: Per-class IoU scores on ADE20k. Bold denotes the best performance.   
+
+<table><tr><td rowspan=2 colspan=1>Classes IDsOccupied area</td><td rowspan=2 colspan=1>Classes IDsOccupied area</td><td rowspan=1 colspan=3>mIoU</td></tr><tr><td rowspan=1 colspan=1>SPADE+(with VGG)</td><td rowspan=1 colspan=1>OASIS without per-class balancing(without VGG)</td><td rowspan=1 colspan=1>OASIS(without VGG)</td></tr><tr><td rowspan=1 colspan=1>0-29</td><td rowspan=1 colspan=1>86.4%</td><td rowspan=1 colspan=1>63.7</td><td rowspan=1 colspan=1>69.1</td><td rowspan=1 colspan=1>68.8</td></tr><tr><td rowspan=1 colspan=1>30 - 59</td><td rowspan=1 colspan=1>7.2%</td><td rowspan=1 colspan=1>47.4</td><td rowspan=1 colspan=1>52.4</td><td rowspan=1 colspan=1>56.6</td></tr><tr><td rowspan=1 colspan=1>60-89</td><td rowspan=1 colspan=1>3.5%</td><td rowspan=1 colspan=1>45.3</td><td rowspan=1 colspan=1>47.0</td><td rowspan=1 colspan=1>51.5</td></tr><tr><td rowspan=1 colspan=1>90 - 119</td><td rowspan=1 colspan=1>1.8%</td><td rowspan=1 colspan=1>29.3</td><td rowspan=1 colspan=1>36.2</td><td rowspan=1 colspan=1>41.5</td></tr><tr><td rowspan=1 colspan=1>120 - 149</td><td rowspan=1 colspan=1>1.0%</td><td rowspan=1 colspan=1>26.2</td><td rowspan=1 colspan=1>31.2</td><td rowspan=1 colspan=1>39.7</td></tr><tr><td rowspan=1 colspan=1>0-149(all classes)</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>42.4</td><td rowspan=1 colspan=1>47.2</td><td rowspan=1 colspan=1>51.6</td></tr></table>
+
+Table D: Per-class IoU scores on Cityscapes.   
+Bold denotes the best performance.
+
+Table C: Per-class IoU scores on COCO-Stuff. Bold denotes the best performance.   
+
+<table><tr><td rowspan=2 colspan=1>Classes IDs</td><td rowspan=2 colspan=1>Area</td><td rowspan=1 colspan=2>mIoU</td></tr><tr><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>OASIS</td></tr><tr><td rowspan=1 colspan=1>0-35</td><td rowspan=1 colspan=1>69.3%</td><td rowspan=1 colspan=1>51.1</td><td rowspan=1 colspan=1>59.0</td></tr><tr><td rowspan=1 colspan=1>36- 69</td><td rowspan=1 colspan=1>15.9%</td><td rowspan=1 colspan=1>43.9</td><td rowspan=1 colspan=1>50.3</td></tr><tr><td rowspan=1 colspan=1>70 - 103</td><td rowspan=1 colspan=1>8.7%</td><td rowspan=1 colspan=1>40.5</td><td rowspan=1 colspan=1>40.9</td></tr><tr><td rowspan=1 colspan=1>104 - 137</td><td rowspan=1 colspan=1>4.5%</td><td rowspan=1 colspan=1>35.9</td><td rowspan=1 colspan=1>36.6</td></tr><tr><td rowspan=1 colspan=1>138 - 171</td><td rowspan=1 colspan=1>1.4%</td><td rowspan=1 colspan=1>22.1</td><td rowspan=1 colspan=1>40.6</td></tr><tr><td rowspan=1 colspan=1>0-171(all classes)</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>38.8</td><td rowspan=1 colspan=1>45.5</td></tr></table>
+
+<table><tr><td rowspan=2 colspan=1>Classes IDs</td><td rowspan=2 colspan=1>Area</td><td rowspan=1 colspan=2>mIoU</td></tr><tr><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>OASIS</td></tr><tr><td rowspan=1 colspan=1>0-2</td><td rowspan=1 colspan=1>75.6%</td><td rowspan=1 colspan=1>91.6</td><td rowspan=1 colspan=1>89.6</td></tr><tr><td rowspan=1 colspan=1>3-6</td><td rowspan=1 colspan=1>18.3%</td><td rowspan=1 colspan=1>75.7</td><td rowspan=1 colspan=1>74.9</td></tr><tr><td rowspan=1 colspan=1>7- 10</td><td rowspan=1 colspan=1>3.9%</td><td rowspan=1 colspan=1>60.0</td><td rowspan=1 colspan=1>66.9</td></tr><tr><td rowspan=1 colspan=1>11 - 14</td><td rowspan=1 colspan=1>1.4%</td><td rowspan=1 colspan=1>60.3</td><td rowspan=1 colspan=1>66.0</td></tr><tr><td rowspan=1 colspan=1>15-18</td><td rowspan=1 colspan=1>0.6%</td><td rowspan=1 colspan=1>38.1</td><td rowspan=1 colspan=1>55.1</td></tr><tr><td rowspan=1 colspan=1>0-18(all classes)</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>63.8</td><td rowspan=1 colspan=1>69.3</td></tr></table>
+
+but not as much as LabelMix (69.3). We suspect that since the images are already partitioned through the label map, an additional partition through CutMix results in a dense patchwork of areas that differ by semantic class and real-fake class identity. This may introduce additional label noise during training for the discriminator. To avoid such inconsistency between semantic classes and real-fake identity, the mask of LabelMix is generated according to the label map, providing natural borders between semantic regions, so that the real and fake objects are placed side-by-side without interfering each other. Under LabelMix regularization, the generator is encouraged to respect the natural semantic class boundaries, improving pixel-level realism while also considering the class segment shapes.
+
+# A.5 ABLATION ON FEATURE MATCHING LOSS
+
+We measure the effect of the feature matching loss (FM) in the absence and presence of the perceptual loss (VGG). Table F and G present the results for OASIS on Cityscapes and SPADE $^ +$ o n ADE20K. For both $\mathrm { S P A D E + }$ and OASIS we observe that the feature matching loss does only affect the FID notably when no perceptual loss is used.
+
+In the case where no perceptual loss is used, we observe that the feature matching prolongs the time until $\mathrm { S P A D E + }$ collapses, resulting in a better FID score (49.7 vs 60.7). Consequently, the mIoU also improves. Hence, the role of the FM loss in the training of $\mathrm { S P A D E + }$ is to stabilize the training through additional self-supervision. This observation is in line with the general observation that SPADE and other semantic image synthesis models require the help of additional losses because the adversarial supervision through the discriminator is not strong enough. In comparison, we did not observe any training collapses in OASIS, despite not using any extra losses. For OASIS, the feature matching loss results in a worse FID (by 0.8 points) in the absence of the perceptual loss. We also observe a degradation of 1.1 mIoU points through the FM loss, in the case where the perceptual supervision is present. This indicates that the FM loss negatively affects the strong supervision from the semantic segmentation adversarial loss of OASIS.
+
+Table E: Ablation study on the impact of LabelMix and CutMix for consistency regularization (CR) in OASIS on Cityscapes. Bold denotes the best performance.
+
+Table G: SPADE $^ +$ on ADE20K. Bold denotes the best performance.   
+
+<table><tr><td rowspan=1 colspan=1>Transformation</td><td rowspan=1 colspan=1>FID↓</td><td rowspan=1 colspan=1>mIoU↑</td></tr><tr><td rowspan=1 colspan=1>No CR</td><td rowspan=1 colspan=1>51.5</td><td rowspan=1 colspan=1>66.3</td></tr><tr><td rowspan=1 colspan=1>CutMix</td><td rowspan=1 colspan=1>52.1</td><td rowspan=1 colspan=1>67.4</td></tr><tr><td rowspan=1 colspan=1>LabelMix</td><td rowspan=1 colspan=1>47.7</td><td rowspan=1 colspan=1>69.3</td></tr></table>
+
+Table F: OASIS on Cityscapes. Bold denotes the best performance.   
+
+<table><tr><td>VGG</td><td>FM</td><td>FID↓</td><td>mIoU↑</td></tr><tr><td></td><td></td><td>47.7</td><td>69.3</td></tr><tr><td></td><td></td><td>48.5</td><td>69.1</td></tr><tr><td>xxν/</td><td>x/x&#x27;</td><td>46.1</td><td>72.0</td></tr><tr><td></td><td></td><td>46.5</td><td>70.9</td></tr></table>
+
+<table><tr><td>VGG</td><td>FM</td><td>FID↓</td><td>mIoU↑</td></tr><tr><td></td><td></td><td>60.7</td><td>21.0</td></tr><tr><td></td><td></td><td>49.7</td><td>32.5</td></tr><tr><td>xx//</td><td>x/x</td><td>32.9</td><td>42.5</td></tr><tr><td></td><td></td><td>32.6</td><td>42.9</td></tr></table>
+
+# A.6 ABLATION ON USING MORE THAN ONE OASIS DISCRIMINATOR
+
+A major difference between SPADE and OASIS is that OASIS employs only one discriminator, while SPADE uses two PatchGAN discriminators at different scales. Naturally, the question arises how OASIS performs with two discriminators at different scales, as in SPADE. For this, Table H presents the FID and mIoU performance of OASIS with two discriminators operating at scales 1 and 0.5 on Cityscapes. One can see that an additional discriminator at scale 0.5 does not improve performance, but slightly worsens it. The reason that no performance gain is visible is that the OASIS discriminator already encodes multi-scale information through its U-Net structure: skip connections between encoder, decoder and individual blocks integrate information at all scales. In contrast, SPADE requires two discriminators to capture information at different scales.
+
+Table H: Comparison of using 1 and 2 discriminators at different scales for OASIS on Cityscapes. Bold denotes the best performance.
+
+<table><tr><td># of OASIS D</td><td>FID↓</td><td>mIoU↑</td></tr><tr><td>1discriminator</td><td>47.7</td><td>69.3</td></tr><tr><td>2 discriminators at different scales (1 and 0.5)</td><td>48.7</td><td>68.8</td></tr></table>
+
+# A.7 ABLATION ON NOISE SAMPLING STRATEGIES DURING TRAINING
+
+Our 3D noise can contain the same sampled vector for each pixel, or different vectors for different regions. This allows for different noise sampling schemes during training. Table I shows the effect of using different methods of sampling 3D noise for different locations during training: Image-level sampling creates one global 1D noise vector and replicates it along the height and width of the label map to create a 3D noise tensor. Region-level sampling relies on generating one 1D noise vector per label, and stacking them in 3D to match the height and width of the label map. Pixel-level sampling creates different noise for every spatial position, with no replication taking place. Mix switches between image-level and region-level sampling via a coin flip decision at every training step. With no obvious winner in performance, we choose the simplest scheme (image-level) for our experiments.
+
+By choosing image-level sampling for training, we thus generate a single 1D latent noise vector of size 64, broadcast it to $6 4 \mathrm { x H x W }$ and concatenate with the label map (NxHxW). This new composite tensor is used as input to the 1st generator layer and at all SPADE-norm layers. The noise is not ignored for the following reasons:
+
+(1) The noise modulates the activations directly at every layer, so it is very hard to ignore. Here, it is important to emphasize how the noise is used: For SPADE it was observed that label maps are paid more attention to if they are used for location-sensitive conditional batch normalization (CBN). Analogously, we observe that the noise is also paid more attention to when it is injected via CBN. Like label maps, which are 3D tensors of stacked one-hot vectors, we stack noise vectors into a 3D tensor of the same dimensions. Thus, in the same way that SPADE is spatially sensitive to labels, OASIS is spatially sensitive to both labels and noise.
+
+(2) The 3D broadcasting strategy provides a spatially uniform signal making it easy to embed semantic meaning into the latent code (see interpolations, Fig. I , J). As noise modulates features at different scales in the generator, matching their resolution, it affects both global and local characteristics. This is why a generator trained with image-level noise can perform region-level manipulation at inference (Fig. F, H). However, more evolved spatial noise sampling schemes can be explored in the future.
+
+Table I: Different noise sampling strategies during training. Bold denotes the best performance.
+
+<table><tr><td rowspan=2 colspan=1>Sampling</td><td rowspan=2 colspan=4>CityscapesFID↓  mIoU↑  MS-SSIM↓</td><td rowspan=2 colspan=3>CityscapesFID↓  mIoU↑  MS-SSIM↓</td></tr><tr><td rowspan=1 colspan=1>FID↓</td></tr><tr><td rowspan=1 colspan=1>image-level</td><td rowspan=1 colspan=1>47.7</td><td rowspan=1 colspan=1>69.3</td><td rowspan=1 colspan=2>0.64</td><td rowspan=1 colspan=1>28.3</td><td rowspan=1 colspan=1>48.8</td><td rowspan=1 colspan=1>0.65</td></tr><tr><td rowspan=1 colspan=1>region-level</td><td rowspan=1 colspan=1>48.1</td><td rowspan=1 colspan=1>69.7</td><td rowspan=1 colspan=2>0.62</td><td rowspan=1 colspan=1>28.8</td><td rowspan=1 colspan=1>48.1</td><td rowspan=1 colspan=1>0.58</td></tr><tr><td rowspan=1 colspan=1>pixel-level</td><td rowspan=1 colspan=1>50.9</td><td rowspan=1 colspan=1>65.5</td><td rowspan=1 colspan=2>0.84</td><td rowspan=1 colspan=1>28.6</td><td rowspan=1 colspan=1>34.0</td><td rowspan=1 colspan=1>0.68</td></tr><tr><td rowspan=1 colspan=1>mix</td><td rowspan=1 colspan=1>46.4</td><td rowspan=1 colspan=1>70.9</td><td rowspan=1 colspan=2>0.68</td><td rowspan=1 colspan=1>28.5</td><td rowspan=1 colspan=1>47.6</td><td rowspan=1 colspan=1>0.66</td></tr></table>
+
+# A.8 ADDITIONAL EXPERIMENTS ON COCO-STUFF
+
+We performed all our extensive ablations on ADE20K and Cityscapes, due to their shorter training time. Training on ADE20K and Cityscapes takes circa 10 days on 4 Tesla V100 GPUs while training on COCO-stuff can stretch to 4 weeks. Therefore, we only executed essential experiments on COCOstuff. We compare the results of these experiments in Table J. For $\mathrm { S P A D E + }$ , it can be seen that without the external perceptual supervision of VGG, training collapses (with FID 99.1 at the best checkpoint before collapse). In contrast, for OASIS image quality is better without VGG (16.7 vs 18.0 FID). When 3D noise is added to OASIS, sampling of multi-modal images is enabled (0.61 vs $1 . 0 ~ \mathrm { M S } -$ SSIM), with very similar performance in synthesis quality (17.0 vs 16.7 FID) and slightly worse mIoU (44.1 vs $4 5 . 5 \ \mathrm { m I o U }$ ) due to the increased variation of generated samples, as the semantic segmentation task of the pre-trained segmentation network becomes harder.
+
+Table J: Performance on COCO-stuff. Bold denotes the best perfromance.   
+
+<table><tr><td>Model</td><td>VGG</td><td colspan="3">3D noisel FID↓ mIoU↑ MS-SSIM↓</td></tr><tr><td>SPADE</td><td>√</td><td>X</td><td>22.6 37.4</td><td>1.0</td></tr><tr><td>SPADE+</td><td>×</td><td>×</td><td>99.1 16.1</td><td>1.0</td></tr><tr><td>SPADE+</td><td>√</td><td>×</td><td>21.7 38.8</td><td>1.0</td></tr><tr><td>OASIS</td><td>X</td><td>×</td><td>16.7 45.5</td><td>1.0</td></tr><tr><td>OASIS</td><td>√</td><td>X</td><td>18.0 44.2</td><td>1.0</td></tr><tr><td>OASIS</td><td>X</td><td>√</td><td>17.0 44.1</td><td>0.61</td></tr></table>
+
+# A.9 ADDITIONAL EVALUATION METRICS
+
+Currently, the FID score is the most widely adopted metric for quantifying image quality of GAN models. However, it is often argued that the FID score does not adequately disentangle synthesis quality and diversity (Kynka¨anniemi et al., 2019). Recently, a series of metrics have been proposed ¨ to address this issue by measuring scores related to the concepts of precision and recall (Ravuri & Vinyals, 2019; Shmelkov et al., 2018; Sajjadi et al., 2018; Kynka¨anniemi et al., 2019). Here, we have ¨ a closer look at the ”improved precision and recall” score proposed by (Kynka¨anniemi et al., 2019), ¨ where precision is the probability that a generated image falls into the estimated support of the real image distribution, and recall is the probability that a real image falls into the estimated support of the generator distribution. Precision and recall can be interpreted as sample quality and diversity. Table K presents a comparison of precision (P) and recall R) between $\mathrm { S P A D E + }$ and OASIS. It can be seen that OASIS outperforms SPADE $^ +$ both in terms of image quality and variety.
+
+Table K: Comparison of the precision and recall metric between SPADE $^ +$ and OASIS. Bold denotes the best performance.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=2>ADE20KP个   R↑</td><td rowspan=1 colspan=2>ADE-outd.P↑   R↑</td><td rowspan=1 colspan=2>CityscapesP个   R↑</td><td rowspan=1 colspan=2>COCO-StuffP个   R↑</td></tr><tr><td rowspan=1 colspan=1>SPADE+</td><td rowspan=1 colspan=1>0.71</td><td rowspan=1 colspan=1>0.52</td><td rowspan=1 colspan=1>0.62</td><td rowspan=1 colspan=1>0.51</td><td rowspan=1 colspan=1>0.54</td><td rowspan=1 colspan=1>0.34</td><td rowspan=1 colspan=1>0.63</td><td rowspan=1 colspan=1>0.56</td></tr><tr><td rowspan=1 colspan=1>OASIS</td><td rowspan=1 colspan=1>0.77</td><td rowspan=1 colspan=1>0.57</td><td rowspan=1 colspan=1>0.77</td><td rowspan=1 colspan=1>0.56</td><td rowspan=1 colspan=1>0.58</td><td rowspan=1 colspan=1>0.55</td><td rowspan=1 colspan=1>0.67</td><td rowspan=1 colspan=1>0.59</td></tr></table>
+
+# B QUALITATIVE RESULTS
+
+# B.1 COMPARISON TO OTHER METHODS
+
+In this section we present a visual comparison between OASIS and other semantic image synthesis methods. Firstly, we show images generated by SPADE (Park et al., 2019), CC-FPSE (Liu et al., 2019) and OASIS on ADE20k, COCO-Stuff, and Cityscapes (in Figures B, C, and D, respectively). A further comparison for SPADE, SPADE+ and OASIS is presented in Figure E. We observed that OASIS often produces more visually plausible images than the previous methods. Our method commonly produces finer textures, especially for complex and large semantic objects, e.g building facades, mountains, water.
+
+We also note that OASIS usually generates brighter and more diverse colors, compared to other methods. As we showed in Section 4 in the main paper, the diversity in colors partially comes from the fact that the feature space of the OASIS generator is not constrained by the VGG loss. We observed that images, generated by SPADE and CC-FPSE, typically have closer colors, while OASIS frequently generates objects with completely different color tones. This also forms one of the failure modes of our approach, when the colors of objects fall out of distribution and seem unnatural (see Figure G).
+
+# B.2 MULTI-MODAL IMAGE SYNTHESIS
+
+Multi-modal image synthesis for a given label map is easy for OASIS: we simply re-sample noise like in a conventional unconditional GAN model. Since OASIS employs a 3D noise tensor (64- channels $\times$ heigh $\times$ width), the noise can be re-sampled entirely (”globally”) or only for specific regions in the 2D image plane (”locally”). For our visualizations, we replicate a single 64-dimensional noise vector along the spatial dimensions for global sampling. For local sampling, we re-sample a new noise vector and use it to replace the global noise vector at every spatial position within a restricted area of interest. The results are shown in Figure F. The generated images are diverse and of high quality. We observe different degrees of variety for different object classes. For example, buildings change drastically in appearance and often change their spatial orientation with respect to the road. On the other side, many common objects (like tables) vary in color, texture, and illumination, but do not change shapes as they are restricted by the fine details of the region that is outlined for them in the label map.
+
+Local noise re-sampling does not have to be restricted to only semantic class areas: in Figure H we sample a different noise vector for the left and right half of the image, as well as for arbitrarily shaped regions. In effect, the two areas can differ substantially. However, often a bridging element is found between two areas, such as clouds extending partly from one region to the other region of the image.
+
+# B.3 LATENT SPACE INTERPOLATIONS
+
+In Figure I we present images that are the results of linear interpolations in the latent space (see Fig. I), using an OASIS model trained on the ADE20K dataset. To generate the images, we sample two noise vectors $z \in \mathbb { R } ^ { 6 4 }$ and interpolate them with three intermediate points. The images are synthesized for these five different noise inputs while the label map is held fixed. Note that in Figure I we only vary the noise globally, not locally (See Section 3.3 in the main paper). In contrast, Figure J shows local interpolations. For this, we only re-sample the 3D noise in the area corresponding to a single semantic class. The effect is that only the appearance of the selected semantic class varies while the rest of the image remains fixed. It can be observed that strong changes in a local area can slightly affect the surroundings if the local area is also very big. As such, the clouds are slightly different in the first and last panel of the mountain row and tree row in Figure J.
+
+We see from Figure I and J that the trajectories in the latent space are smooth and semantically meaningful. For example, we observe transitions from winter to summer, day to night, green trees to leafless trees, shiny parquet to matt carpet, as well as smooth transitions between buildings with different architectural styles.
+
+# B.4 APPLICATION TO UNLABELLED DATA
+
+OASIS has a unique property that its discriminator is trained to be an image segmenter. We observed that it shows good performance on this task, reaching the mIoU of 40.0 on ADE20K validation set. For comparison, current state of the art on ADE20K is a mIoU of 46.91, achieved by ResNeST (Zhang et al., 2020). Such a good segmentation performance allows OASIS to be applied to unlabelled images: given an unseen image without a ground truth annotation, OASIS can predict a label map via the discriminator. Subsequently feeding this prediction to the generator allows to synthesize a scene with the same layout but different style. This property is shown in Fig. K. Due to the good segmentation performance, the recreated scenes closely follow the ground truth label map of the original image. The high sensitivity of OASIS to the 3D noise enforces good variability, so the recreations are different from each other. We believe that creating multiple versions of one image while retaining the layout can be useful for data-augmentation.
+
+# B.5 LABELMIX
+
+Figure L shows additional visual examples of LabelMix regularization, as described in Section 3.2 in the main paper. It can be seen that the discriminator prediction on the mixed images often differs from the mix of individual predictions on real and fake images. In particular, regions that are classified as real in the latter are classified as fake when the images are mixed. This means that the discriminator takes the global context into account for local predictions and thereby often bases the prediction on arbitrary details that should not affect the real-fake class identity. In return, the consistency regularization helps to minimize the difference between these two predictions.
+
+![](images/e50c53e283617bfeef899b2a45f7d86bcf07a02a7b5fa04631fddcf58fda726c.jpg)  
+Figure B: Qualitative comparison of OASIS with other methods on ADE20K.
+
+![](images/221ce18936dfe0da7c4a8c36c752725a08611e0dd58386e47ee6a3e103c0e2f9.jpg)  
+Figure C: Qualitative comparison of OASIS with other methods on COCO-Stuff.
+
+![](images/399f3a9f3e87062760176e240e479e3894594ad019bb8fcdbc9dc3d6de2b8560.jpg)  
+Figure D: Qualitative comparison of OASIS with other methods on Cityscapes.
+
+![](images/936d6b871373ed940973834ef9d4dd846c2f5f7cc58540d53fc1321f52ea8379.jpg)  
+Figure E: Qualitative comparison of OASIS with SPADE and SPADE $^ +$ using ADE20K (row 1-3), COCO-stuff (row 4-6) and Cityscapes (row 7-9).
+
+![](images/4ec13a1c49a3ebe17b625f551ab0220c46d66fdc276e9fc6d8d06c6ca4a6bb0c.jpg)  
+Figure F: Images generated by OASIS on ADE20K with $2 5 6 \times 2 5 6$ resolution using different 3D noise inputs. For each label map the noise is re-sampled globally (first row) or locally in the areas marked in red (second row). Note that the images are not stitched together but generated in single forward passes.
+
+![](images/e6e6792e352a4549ea9f5cb014ff4704f4949d971a754709b2c426a071f3c230.jpg)  
+Figure G: Failure mode of OASIS. Our model generates diverse images, sometimes producing object with outlier colors and textures. We compare to Park et al. (2019) and Liu et al. (2019).
+
+![](images/920e592673c7690bf09dcf8a4b9f82eccfb6fa7efb8bd7949ecd221f9c363508.jpg)  
+Figure H: Images generated by OASIS in one forward pass (no collage), with different noise vectors for different image regions.
+
+![](images/a5f108b01e438a6ee73b3af288d549001e8cfc2459938fd48d7701559489d0e9.jpg)  
+Figure I: Global latent space interpolations between images generated by OASIS for various outdoor and indoor scenes in the ADE20K dataset at resolution $2 5 6 \times 2 5 6$ .
+
+![](images/9a5e4e46440c67344a51893b1752d01a18d8b0e5a2a07e684d30473ab5301c7d.jpg)  
+Figure J: Latent space interpolations in local regions of the 3D noise, corresponding to a single semantic class. The noise is only changed within the restricted area. Trained on the ADE20K dataset at resolution $2 5 6 \times 2 5 6$ .
+
+![](images/5f120d2929c5a476e0f6d3cd550c83758db35a85776e17cd1a58cb16c70e6018.jpg)  
+Figure K: After training, the OASIS discriminator can be used to segment images. Columns 1- 3 show the ground truth label map, real image, and segmentation of the discriminator. Using the predicted label map the generator can produce multiple versions of the original image by resampling noise (Recreations 1-3). Note that this alleviates the need of ground truth maps during inference.
+
+![](images/3a1a6e3b6a99e65601b5d029d316bc29e9f03b8f632ba7a7e0494050e27e6219.jpg)  
+Figure L: Visual examples of LabelMix regularization. Real $x$ and fake $\hat { x }$ images are mixed using a binary mask $M$ , sampled based on the label map, resulting in LabelMix $( x , { \hat { x } } )$ . The consistency regularization then minimizes the distance between the logits of DLabelMix(x,xˆ) and L $\mathrm { \ a b e l M i x } _ { ( D _ { x } , D _ { \hat { x } } ) }$ . In this visualization, black corresponds to the fake class in the $N { + 1 }$ segmentation output.
+
+# C ARCHITECTURAL AND TRAINING DETAILS
+
+The architecture of OASIS builds upon SPADE Park et al. (2019). In the following, we describe in detail our proposed changes to the discriminator and the generator.
+
+# C.1 DISCRIMINATOR ARCHITECTURE
+
+This OASIS discriminator follows a U-Net architecture and is built from ResNet blocks, inspired in their design by Brock et al. (2019). The architecture of the OASIS discriminator is outlined in Table L. It has in total 22M learnable parameters and is bigger than the multi-scale PatchGAN discriminator (5.5M) used by SPADE Park et al. (2019). The increased capacity of the OASIS discriminator allows it to learn a more powerful representation and provide more informative feedback to the generator.
+
+Table L: The OASIS discriminator. N refers to the number of semantic classes.   
+
+<table><tr><td>Operation</td><td>Input</td><td>Size</td><td>Output</td><td>Size</td></tr><tr><td>ResBlock-Down</td><td>image</td><td>(3,256,256)</td><td>down_1</td><td>(128,128,128)</td></tr><tr><td>ResBlock-Down</td><td>down_1</td><td>(128,128,128)</td><td>down_2</td><td>(128,64,64)</td></tr><tr><td>ResBlock-Down</td><td>down_2</td><td>(128,64,64)</td><td>down_3</td><td>(256,32,32)</td></tr><tr><td>ResBlock-Down</td><td>down_3</td><td>(256,32,32)</td><td>down_4</td><td>(256,16,16)</td></tr><tr><td>ResBlock-Down</td><td>down_4</td><td>(256,16,16)</td><td>down_5</td><td>(512,8,8)</td></tr><tr><td>ResBlock-Down</td><td>down_5</td><td>(512,8,8)</td><td>down_6</td><td>(512,4,4)</td></tr><tr><td>ResBlock-Up</td><td>down_6</td><td>(512,4,4)</td><td>up_1</td><td>(512,8,8)</td></tr><tr><td>ResBlock-Up</td><td>cat(up_1， down_5)</td><td>(1024,8,8)</td><td>up_2</td><td>(256,16,16)</td></tr><tr><td>ResBlock-Up</td><td>cat(up_2， down_4)</td><td>(512,16,16)</td><td>up_3</td><td>(256,32,32)</td></tr><tr><td>ResBlock-Up</td><td>cat(up_3， down_3)</td><td>(512,32,32)</td><td>up_4</td><td>(128,64,64)</td></tr><tr><td>ResBlock-Up</td><td>cat(up_4， down_2)</td><td>(256,64,64)</td><td>up_5</td><td>(128,128,128)</td></tr><tr><td>ResBlock-Up</td><td>cat(up_5， down_1)</td><td>(256,128,128)</td><td>up_6</td><td>(64,256,256)</td></tr><tr><td>Conv2D</td><td>up_6</td><td>(64,256,256)</td><td>out</td><td>(N+1,256,256)</td></tr></table>
+
+# C.2 GENERATOR ARCHITECTURE
+
+The generator architecture is built from SPADE ResNet blocks and includes a concatenation of 3D noise with the label map along the channel dimension as an option. The generator can be either trained directly on the label maps or with 3D noise concatenated to the label maps. The latter option is shown in Table M.
+
+OASIS generator drops the first residual block used in Park et al. (2019), which decreases the number of learnable parameters from 96M to 72M. The optional 3D noise injection brings additionally 2M parameters. This sampling scheme is five times lighter than the image encoder used by SPADE (10M).
+
+# C.3 LEARNING OBJECTIVE AND TRAINING DETAILS
+
+Learning objective. We train our model with $( N { + } 1 )$ -class cross entropy as an adversarial loss. Additionally, the discriminator is regularized with the proposed LabelMix consistency regularization. The full OASIS learning objective thus takes the following form:
+
+$$
+\begin{array} { l } { { \displaystyle { \mathcal E } _ { G } ^ { 0 \mathrm { A S I S } } = - { \mathbb E } _ { ( z , t ) } \left[ \displaystyle { \sum _ { c = 1 } ^ { N } \alpha _ { c } \sum _ { i , j } ^ { H \times W } t _ { i , j , c } \log D ( G ( z , t ) ) _ { i , j , c } } \right] } , }  \\ { { \displaystyle { \mathcal E } _ { D } ^ { 0 \mathrm { A S I S } } = - { \mathbb E } _ { ( x , t ) } \left[ \displaystyle { \sum _ { c = 1 } ^ { N } \alpha _ { c } \sum _ { i , j } ^ { H \times W } t _ { i , j , c } \log D ( x ) _ { i , j , c } } \right] - { \mathbb E } _ { ( z , t ) } \left[ \displaystyle { \sum _ { i , j } ^ { H \times W } \log D ( G ( z , t ) ) _ { i , j , c = N + 1 } } \right] + } } \\ { { \displaystyle \qquad + \lambda _ { \mathrm { L M } } \Big \| D _ { \mathrm { l o g i t s } } \Big ( \mathrm { L a b e l M i x } ( x , \hat { x } , M ) \Big ) - \mathrm { L a b e l M i x } \Big ( D _ { \mathrm { l o g i t s } } ( x ) , D _ { \mathrm { l o g i t s } } ( \hat { x } ) , M \Big ) \Big \| _ { 2 } ^ { 2 } , } }  \end{array}
+$$
+
+where $x$ denotes the real image and $( z , t )$ is the noise-label map.
+
+Table M: The OASIS generator. N refers to the number of semantic classes, z is noise sampled from a unit Gaussian, y is the label map, interp interpolates a given input to the appropriate spatial dimensions of the current layer.   
+
+<table><tr><td>Operation</td><td>Input</td><td>Size</td><td>Output Size</td><td></td></tr><tr><td>Concatenate</td><td>z_3D Y</td><td>(64,256,256) (N,256,256)</td><td>Z-Y</td><td>(64+N,256,256)</td></tr><tr><td>Conv2D</td><td>interp(z-y)</td><td>(64+N,8,8)</td><td>X</td><td>(1024,8,8)</td></tr><tr><td>SPADE-ResBlock</td><td>X interp(z-y)</td><td>(1024,8,8) (64+N,8,8)</td><td>up_1</td><td>(1024,16,16)</td></tr><tr><td>SPADE-ResBlock</td><td>up_1 interp(z-y)</td><td>(1024,16,16) (64+N,16,16)</td><td>up_2</td><td>(512,32,32)</td></tr><tr><td>SPADE-ResBlock</td><td>up_2 interp(z-y)</td><td>(512,32,32) (64+N,32,32)</td><td>up_3</td><td>(256,64,64)</td></tr><tr><td>SPADE-ResBlock</td><td>up_3 interp(z-y)</td><td>(256,64,64) (64+N,64,64)</td><td>up_4</td><td>(128,128,128)</td></tr><tr><td>SPADE-ResBlock</td><td>up_4 interp(z-y)</td><td>(128,128,128) (64+N,128,128)</td><td>up_5</td><td>(64,256,256)</td></tr><tr><td>Conv2D,LeakyRelu, TanH</td><td>up_5</td><td>(64,256,256)</td><td>X</td><td>(3,256,256)</td></tr></table>
+
+Our objective function is different from SPADE. Their model uses hinge adversarial loss and adds the VGG perceptual loss and a feature matching loss to train the generator. For an easier comparison, we provide the objective function of SPADE:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { G } ^ { \mathrm { S P A D E } } = - \mathbb { E } _ { ( z , t ) } \left[ D ( t , G ( z , t ) ) \right] + \lambda _ { \mathrm { F M } } \mathbb { E } _ { ( z , t , x ) } \displaystyle \sum _ { i = 1 } ^ { T } \| D _ { k } ^ { ( i ) } ( t , x ) - D _ { k } ^ { ( i ) } ( t , G ( z , t ) ) \| _ { 1 } + } \\ & { ~ + \lambda _ { \mathrm { V G G } } \mathbb { E } _ { ( z , t , x ) } \displaystyle \sum _ { i = 1 } ^ { N } \| F ^ { ( i ) } ( x ) - F ^ { ( i ) } ( G ( z , t ) ) \| _ { 1 } , } \\ & { \mathcal { L } _ { D } ^ { \mathrm { S P A D E } } = - \mathbb { E } _ { ( t , x ) } \left[ \operatorname* { m i n } _ { \ldots \ldots \ldots } ( D , - 1 + D _ { i } ( t , x ) ) \right] - \mathbb { E } _ { ( z , t ) } \left[ \operatorname* { m i n } ( 0 , - 1 - \log D ( t , G ( z , t ) ) \right] , } \end{array}
+$$
+
+Training details. We follow the experimental setting of (Park et al., 2019). The image resolution is set to $2 5 6 \mathrm { x } 2 5 6$ for ADE20K and COCO-Stuff and 256x512 for Cityscapes. The Adam (Kingma & Ba, 2015) optimizer was used with momentums $\beta ~ = ~ ( 0 , 0 . 9 9 9 )$ and constant learning rates $( 0 . 0 0 0 1 , 0 . 0 0 0 4 )$ for $G$ and $D$ . We did not apply the GAN feature matching loss, and used the VGG perceptual loss only for ablations with $\lambda _ { \mathrm { V G G } } = 1 0$ . The coefficient for LabelMix $\lambda _ { \mathrm { L M } }$ was set to 5 for ADE20k and Cityscapes, and to 10 for COCO-Stuff. All our models use an exponential moving average (EMA) of the generator weights with 0.9999 decay (Brock et al., 2019). All the experiments were run on 4 Tesla V100 GPUs, with a batch size of 20 for Cityscapes, and 32 for ADE20k and COCO-Stuff. The training epochs are 200 on ADE20K and Cityscapes, and 100 for the larger COCO-Stuff dataset. On average, a complete forward-backward pass with batch size 32 on Ade20k takes around $0 . 9 5 \mathrm { m s }$ per training image.