Title: Explore to Generalize in Zero-Shot RL
Venue: NeurIPS 2023
Accepted: yes
Keywords: Reinforcement Learning

Generalization

State Space Maximum Entropy Exploration
Abstract: We study zero-shot generalization in reinforcement learning - optimizing a policy on a set of training tasks to perform well on a similar but unseen test task. 
To mitigate overfitting, previous work explored different notions of invariance to the task. However, on problems such as the ProcGen Maze, an adequate solution that is invariant to the task visualization does not exist, and therefore invariance-based approaches fail. 
Our insight is that learning a policy that effectively $\textit{explores}$ the domain is harder to memorize than a policy that maximizes reward for a specific task, and therefore we expect such learned behavior to generalize well; we indeed demonstrate this empirically on several domains that are difficult for invariance-based approaches. Our $\textit{Explore to Generalize}$ algorithm (ExpGen) builds on this insight: we train an additional ensemble of agents that optimize reward. At test time, either the ensemble agrees on an action, and we generalize well, or we take exploratory actions, which generalize well and drive us to a novel part of the state space, where the ensemble may potentially agree again. We show that our approach is the state-of-the-art on tasks of the ProcGen challenge that have thus far eluded effective generalization, yielding a success rate of 83% on the Maze task and 74% on Heist with $200$ training levels. ExpGen can also be combined with an invariance based approach to gain the best of both worlds, setting new state-of-the-art results on ProcGen.
Code available at [https://github.com/EvZissel/expgen](https://github.com/EvZissel/expgen).

Explore to Generalize in Zero-Shot RL

Abstract

We study zero-shot generalization in reinforcement learning-optimizing a policy on a set of training tasks to perform well on a similar but unseen test task. To mitigate overfitting, previous work explored different notions of invariance to the task. However, on problems such as the ProcGen Maze, an adequate solution that is invariant to the task visualization does not exist, and therefore invariance-based approaches fail. Our insight is that learning a policy that effectively explores the domain is harder to memorize than a policy that maximizes reward for a specific task, and therefore we expect such learned behavior to generalize well; we indeed demonstrate this empirically on several domains that are difficult for invariancebased approaches. Our Explore to Generalize algorithm (ExpGen) builds on this insight: we train an additional ensemble of agents that optimize reward. At test time, either the ensemble agrees on an action, and we generalize well, or we take exploratory actions, which generalize well and drive us to a novel part of the state space, where the ensemble may potentially agree again. We show that our approach is the state-of-the-art on tasks of the ProcGen challenge that have thus far eluded effective generalization, yielding a success rate of 83% on the Maze task and 74% on Heist with 200 training levels. ExpGen can also be combined with an invariance based approach to gain the best of both worlds, setting new state-of-the-art results on ProcGen. Code available at https://github.com/EvZissel/expgen .

1 Introduction

Recent developments in reinforcement learning (RL) led to algorithms that surpass human experts in a broad range of tasks [Mnih et al., 2015, Vinyals et al., 2019, Schrittwieser et al., 2020, Wurman et al., 2022]. In most cases, the RL agent is tested on the same task it was trained on, and is not guaranteed to perform well on unseen tasks. In zero-shot generalization for RL (ZSG-RL), however, the goal is to train an agent on training domains to act optimally in a new, previously unseen test environment [Kirk et al., 2021]. A standard evaluation suite for ZSG-RL is the ProcGen benchmark [Cobbe et al., 2020], containing 16 games, each with levels that are procedurally generated to vary in visual properties (e.g., color of agents in BigFish, Fig. 1a, or background image in Jumper, Fig. 1c) and dynamics (e.g., wall positions in Maze, Fig. 1d, and key positions in Heist, Fig. 1e).

Previous studies focused on identifying various invariance properties in the tasks, and designing corresponding invariant policies , through an assortment of regularization and augmentation techniques [Igl et al., 2019, Cobbe et al., 2019, Wang et al., 2020, Lee et al., 2019a, Raileanu et al., 2021, Raileanu and Fergus, 2021, Cobbe et al., 2021, Sonar et al., 2021, Bertran et al., 2020, Li et al., 2021]. For example, a policy that is invariant to the color of agents is likely to generalize well in BigFish. More intricate invariances include the order of observations in a trajectory [Raileanu and Fergus, 2021], and the length of a trajectory, as reflected in the value function [Raileanu and Fergus, 2021].

(a) BigFish

(b) Plunder

(c) Jumper

(d) Maze

(e) Heist

Can ZSG-RL be reduced to only finding invariant policies? As a counter-argument, consider the following thought experiment 2 . Imagine Maze, but with the walls and goal hidden in the observation (Fig. 1f). Arguably, this is the most task-invariant observation possible, such that a solution can still be obtained in a reasonable time. An agent with memory can be trained to optimally solve all training tasks: figuring out wall positions by trying to move ahead and observing the resulting motion, and identifying based on its movement history in which training maze it is currently in. Obviously, such a strategy will not generalize to test mazes. Indeed, as depicted in Figure 2, performance in tasks like Maze and Heist, where the strategy for solving any particular training task must be indicative of that task, has largely not improved by methods based on invariance (e.g. UCB-DrAC and IDAAC).

Interestingly, decent zero-shot generalization can be obtained even without a policy that generalizes well. As described by Ghosh et al. [2021], an agent can overcome test-time errors in its policy by treating the perfect policy as an unobserved variable. The resulting decision making problem, termed the epistemic POMDP , may require some exploration at test time to resolve uncertainty. Ghosh et al. [2021] further proposed the LEEP algorithm based on this principle, which trains an ensemble of agents and essentially chooses randomly between the members when the ensemble does not agree, and was the first method to present substantial generalization improvement on Maze.

In this work, we follow the epistemic POMDP idea, but ask: how to improve exploration at test time? Our approach is based on a novel discovery: when we train an agent to explore the training domains using a maximum entropy objective [Hazan et al., 2019, Mutti et al., 2021], we observe that the learned exploration behavior generalizes surprisingly well-much better than the generalization attained when training the agent to maximize reward. Intuitively, this can be explained by the fact that reward is a strong signal that leads to a specific behavior that the agent can 'memorize' during training, while exploration is naturally more varied, making it harder to memorize and overfit.

BigFish

Plunder

Jumper

Maze

Heist

0.2

0.0

0.2

0.4

0.6

0.8

Normalized test performance on five ProcGen games

PPO

UCB-DrAC

IDAAC

LEEP

ExpGen-PPO

ExpGen-IDAAC

Exploration by itself, however, is not useful for solving new tasks. Our algorithm, Explore to Generalize (ExpGen), additionally trains an ensemble of reward-seeking agents. At test time, either the ensemble agrees on an action, and we generalize well, or we take exploratory actions using the exploration policy , which we demonstrate to generalize, and drive us to a novel part

of the state space, where the ensemble may potentially agree again.

ExpGen is simple to implement, and can be used with any reward maximizing RL algorithm. Combined with vanilla PPO, ExpGen significantly improves the state-of-the-art (SOTA) on several ProcGen games for which previous methods fail (see Fig. 2). ExpGen also significantly improves

upon LEEP, due to its effective test-time exploration strategy. For example, on Maze with 200 training levels, our method obtains 83% success on test tasks, whereas the previous state-of-the-art achieved 66% . When combined with IDAAC [Raileanu and Fergus, 2021], the leading invariance-based algorithm, ExpGen achieves state-of-the-art performance on the full ProcGen suite (the full results are provided in Appendix D).

2 Related Work

Generalization in RL The recent survey by Kirk et al. [2021] provides an extensive review of generalization in RL; here, we provide a brief overview. One approach to generalization is by artificially increasing the number of training tasks, using either procedural generation [Cobbe et al., 2019, 2020], or augmentations [Kostrikov et al., 2020, Ye et al., 2020, Lee et al., 2019a, Raileanu et al., 2021], task interpolation [Yao et al., 2021] or various regularization technique, such as dropout [Igl et al., 2020] and batch normalization [Farebrother et al., 2018, Igl et al., 2020]. Leading approaches, namely IDAAC [Raileanu and Fergus, 2021] and PPG [Cobbe et al., 2021], investigate the advantages of decoupling policy and value functions for generalization, whereas Jiang et al. [2021] propose automatic curriculum learning of levels.

A different approach is to add inductive bias to the neural network policy or learning algorithm. Approaches such as Tamar et al. [2016], Vlastelica et al. [2021], Boutilier et al. [2020] embed a differentiable planner or learning algorithm into the neural network. Other methods [Kansky et al., 2017, Toyer et al., 2018, Rivlin et al., 2020] combine learning with classical graph planning to generalize across various planning domains. These approaches require some knowledge about the problem structure (e.g., a relevant planning algorithm), while our approach does not require any task-specific knowledge. Another line of work aims to learn policies or features that are invariant across the different training tasks [Sonar et al., 2021, Bertran et al., 2020, Li et al., 2021, Igl et al., 2019, Stooke et al., 2021, Mazoure et al., 2020] and are thus more robust to sensory variations.

Using an ensemble to direct exploration to unknown areas of the state space was proposed in the model-based TEXPLORE algorithm of Hester and Stone [2013], where an ensemble of transition models was averaged to induce exploratory actions when the models differ in their prediction. Observing that exploration can help with zero-shot generalization, the model-free LEEP algorithm by Ghosh et al. [2021] is most relevant to our work. LEEP trains an ensemble of policies, each on a separate subset of the training environment, with a loss function that encourages agreement between the ensemble members. Effectively, the KL loss in LEEP encourages random actions when the agents of the ensemble do not agree, which is related to our method. However, random actions can be significantly less effective in exploring a domain than a policy that is explicitly trained to explore, such as a maximum-entropy policy. Consequentially, we observe that our approach leads to significantly better performance at test time.

State Space Maximum Entropy Exploration Maximum entropy exploration (maxEnt, Hazan et al. 2019, Mutti et al. 2021) is an unsupervised learning framework that trains policies that maximize the entropy of their state-visitation frequency, leading to a behavior that continuously explores the environment state space. Recently, maximum entropy policies have gained attention in RL [Liu and Abbeel, 2021b,a, Yarats et al., 2021, Seo et al., 2021, Hazan et al., 2019, Mutti et al., 2021] mainly in the context of unsupervised pre-training. In that setting, the agent is allowed to train for a long period without access to environment rewards, and only during test the agent gets exposed to the reward signal and performs a limited fine-tuning adaptation learning. Importantly, these works expose the agent to the same environments during pre-training and test phases, with the only distinction being the lack of extrinsic reward during pre-training. To the best of our knowledge, our observation that maxEnt policies generalize well in the zero-shot setting is novel.

3 Problem Setting and Background

We describe our problem setting and provide background on maxEnt exploration.

Reinforcement Learning (RL)

In Reinforcement Learning an agent interacts with an unknown, stochastic environment and collects rewards. This is modeled by a Partially Observed Markov Decision Process (POMDP) [Bertsekas, 2012], which is the tuple M = ( S, A, O, P init , P, Σ , r, γ ) , where S ∈ R | S | and A ∈ R | A | are the state and actions spaces, O is the observation space, P init is an initial state distribution, P is the transition kernel, Σ is the observation function, r : S × A → R is the reward function, and γ ∈ [0 , 1) is the discount factor. The agent starts from initial state s 0 ∼ P init and at time t performs an action a t on the environment that yields a reward r t = r ( s t , a t ) , and an observation o t = Σ( s t , a t ) ∈ O . Consequently, the environment transitions into the next state according to s t +1 ∼ P ( ·| s t , a t ) . Let the history at time t be h t = { o 0 , a 0 , r 0 , o 1 , a 1 , r 1 . . . , o t } , the sequence of observations, actions and rewards. The agent's next action is outlined by a policy π , which is a stochastic mapping from the history to an action probability π ( a | h t ) = P ( a t = a | h t ) . In our formulation, a historydependent policy (and not a Markov policy) is required both due to partially observed states, epistemic uncertainty [Ghosh et al., 2021], and also for optimal maxEnt exploration [Mutti et al., 2022].

Zero-Shot Generalization for RL

We assume a prior distribution over POMDPs P ( M ) , defined over some space of POMDPs. For a given POMDP, an optimal policy maximizes the expected discounted return E π,M [ ∑ ∞ t =0 γ t r ( s t , a t )] , where the expectation is taken over the policy π ( h t ) , and the state transition probability s t ∼ P of POMDP M . Our generalization objective in this work is to maximize the discounted cumulative reward taken in expectation over the POMDP prior , also termed the population risk :

Seeking a policy that performs well in expectation over any POMDP from the prior corresponds to zero-shot generalization.

We assume access to N training POMDPs M 1 , . . . , M N sampled from the prior, M i ∼ P ( M ) . Our goal is to use M 1 , . . . , M N to learn a policy that performs well on objective 1. A common approach is to optimize the empirical risk objective:

̸

where the empirical POMDP distribution can be different from the true distribution, i.e. ˆ P ( M ) = P ( M ) . In general, a policy that optimizes the empirical risk (Eq. 2) may perform poorly on the population risk (Eq. 1)-this is known as overfitting in statistical learning theory [Shalev-Shwartz and Ben-David, 2014], and has been analyzed recently also for RL [Tamar et al., 2022].

Maximum Entropy Exploration

In the following we provide the definitions for the state distribution and the maximum entropy exploration objective. For simplicity, we discuss MDPs-the fully observed special case of POMDPs where O = S , and Σ( s, a ) = s .

A policy π , through its interaction with an MDP, induces a t -step state distribution d t,π ( s ) = p ( s t = s | π ) over the state space S . Let d t,π ( s, a ) = p ( s t = s, a t = a | π ) be its t -step state-action counterpart. For the infinite horizon setting, the stationary state distribution is defined as d π ( s ) = lim t →∞ d t,π ( s ) , and its γ -discounted version as d γ,π ( s ) = (1 -γ ) ∑ ∞ t =0 γ t d t,π ( s ) . We denote the state marginal distribution as d T,π ( s ) = 1 T ∑ T t =0 d t,π ( s ) , which is a marginalization of the t -step state distribution over a finite time T . The objective of maximum entropy exploration is given by:

where d can be regarded as either the stationary state distribution d π [Mutti and Restelli, 2020], the discounted state distribution d γ,π [Hazan et al., 2019] or the marginal state distribution d T,π [Lee et al., 2019b, Mutti and Restelli, 2020]. In our work we focus on the finite horizon setting and

adapt the marginal state distribution d T,π in which T equals the episode horizon H , i.e. we seek to maximize the objective:

which yields a policy that 'equally' visits all states during the episode. Existing works that target maximum entropy exploration rely on estimating the density of the agent's state visitation distribution [Hazan et al., 2019, Lee et al., 2019b]. More recently, a branch of algorithms that employ nonparametric entropy estimation [Liu and Abbeel, 2021a, Mutti et al., 2021, Seo et al., 2021] has emerged, circumventing the burden of density estimation. Here, we follow this common thread and adapt the non-parametric entropy estimation approach; we estimate the entropy using the particlebased k -nearest neighbor ( k -NN estimator) [Beirlant et al., 1997, Singh et al., 2003], as elaborated in the next section.

4 The Generalization Ability of Maximum Entropy Exploration

In this section we present an empirical observation-policies trained for maximum entropy exploration (maxEnt policy) generalize well. First, we explain the training procedure of our maxEnt policy, then we show empirical results supporting this observation.

4.1 Training State Space Maximum Entropy Policy

To tackle objective (4), we estimate the entropy using the particle-based k -NN estimator [Beirlant et al., 1997, Singh et al., 2003], as described here. Let X be a random variable over the support χ ⊂ R m with a probability mass function p . Given the probability of this random variable, its entropy is obtained by H X ( p ) = -E x ∼ p [log( p )] . Without access to its distribution p , the entropy can be estimated using N samples { x i } N i =1 by the k -NN estimator Singh et al. [2003]:

where x k -NN i is the k -NN sample of x i from the set { x i } N i =1 .

To estimate the distribution d H,π over the states S , we consider each trajectory as H samples of states { s t } H t =1 and take s k -NN t to be the k -NN of the state s t within the trajectory, as proposed by previous works (APT, Liu and Abbeel [2021a], RE3, Seo et al. [2021], and APS, Liu and Abbeel [2021a]),

Next, similar to previous works, since this sampled estimation of the entropy (Eq. 6) is a sum of functions that operate on each state separately, it can be considered as an expected reward objective ˆ H k,H ( d H,π ) ≈ 1 H ∑ H t =1 r I ( s t ) with the intrinsic reward function:

This formulation enables us to deploy any RL algorithm to approximately optimize objective (4). Specifically, in our work we use the policy gradient algorithm PPO [Schulman et al., 2017], where at every time step t the state s k -NN t is chosen from previous states { s i } t -1 i =1 of the same episode.

Another challenge stems from the computational complexity of calculating the L 2 norm of the k -NN (Eq. 7) at every time step t . To improve computational efficiency, we introduce the following approximation: instead of taking the full observation as the state s i (i.e. 64 × 64 RGB image), we sub-sample (denoted ↓ ) the observation by applying average pooling of 3 × 3 to produce an image s ↓ i of size 21 × 21 , resulting in:

200

500

1000

5000

# Levels

0

10

20

30

40

50

maxEnt Score

Maze

Train

Test

200

500

1000

5000

# Levels

0

10

20

30

40

50

60

maxEnt Score

Jumper

200

500

1000

5000

# Levels

0

10

20

30

40

50

60

70

80

90

maxEnt Score

Miner

(a) Entropy Reward

200

500

1000

5000

# Levels

0

2

4

6

8

10

Score

Maze

200

500

1000

5000

# Levels

0

2

4

6

8

10

Score

Jumper

200

500

1000

5000

# Levels

0

2

4

6

8

10

12

Score

Miner

(b) Extrinsic Reward

We emphasize that we do not modify the termination condition of each game. However, a maxEnt policy will learn to avoid termination, as this increases the sum of intrinsic rewards. In Figure 3 we display the states visited by a maxEnt policy on Maze. We also experimented with L 0 as the state similarity measure instead of L 2 , which resulted in similar performance (see Appendix F.2).

4.2 Generalization of maxEnt Policy

The generalization gap describes the difference between the reward accumulated during training R emp ( π ) and testing R pop ( π ) of a policy, where we approximate the population score by testing on a large population of tasks withheld during training. We can evaluate the generalization gap for either an extrinsic reward, or for an intrinsic reward, such as the reward that elicits maxEnt exploration (Eq. 8). In the latter, the generalization gap captures how well the agent's exploration strategy generalizes.

We found that agents trained for maximum entropy exploration exhibit a smaller generalization gap compared with the standard approach of training solely with extrinsic reward. Intuitively, this can be attributed to the extrinsic reward serving as an 'easy' signal to learn from, and overfit to in the training environments. To assess the generalization quality of the maxEnt policy, we train agents on 200 , 500 , 1000 and 5000 instances of ProcGen's Maze, Jumper and Miner environments using the intrinsic reward (Eq. 8). The policies are equipped with a memory unit (GRU, Cho et al. 2014) to allow learning of deterministic policies that maximize the entropy [Mutti et al., 2022] 3 .

The train and test return scores are shown in Fig. 4a. In all three environments, we demonstrate a small generalization gap, as test performance on unseen levels closely follows the performance achieved during training. When considering Maze trained on 200 levels, we observe a small generalization gap of 1 . 7% , meaning test performance closely follows train performance. For Jumper and Miner the maxEnt policy exhibits a small generalization gap of 8 . 5% and 4 . 3% , respectively. In addition, we verify that the train results are near optimal by comparing with a hand designed approximately optimal exploration policy. For example, on Maze we use the well known maze exploring strategy wall follower , also known as the left/right-hand rule [Hendrawan, 2020]; see Appendix B.2 for details.

Next, we evaluate the generalization gap of agents trained to maximize the extrinsic reward 4 . The results for this experiment, shown in Fig. 4b, illustrate that the generalization gap for extrinsic reward

is more prominent. For comparison, when trained on 200 levels, the figure shows a large generalization gap for Maze ( 38 . 8% ) and Jumper ( 27 . 5% ), while Miner exhibits a moderate generalization gap of 13 . 1% . For an evaluation on all ProcGen games, please see Appendix B.1.

5 Explore to Generalize (ExpGen)

Our main insight is that, given the generalization property of the entropy maximization policy established above, an agent can apply this behavior in a test MDP and expect effective exploration at test time . In the following, we pair this insight with the epistemic POMDP idea, and propose to play the exploration policy when the agent faces epistemic uncertainty, hopefully driving the agent to a different state where the reward-seeking policy is more certain. This can be seen as an adaptation of the seminal explicit explore or exploit idea [Kearns and Singh, 2002], to the setting of ZSG-RL.

5.1 Algorithm

Our framework comprises two parts: an entropy maximizing network and an ensemble of networks that maximize an extrinsic reward to evaluate epistemic uncertainty. The first step entails training a network equipped with a memory unit to obtain a maxEnt policy π H that maximizes entropy, as described in section 4.1. Next, we train an ensemble of memory-less policy networks { π j r } j m =1 to maximize extrinsic reward. Following Ghosh et al. [2021], we shall use the ensemble to assess epistemic uncertainty. Different from Ghosh et al. [2021], however, we do not change the RL loss function, and use an off-the-shelf RL algorithm (such as PPO [Schulman et al., 2017] or IDAAC [Stooke et al., 2021]).

At test time, we couple these two components into a combined agent π (detailed as pseudo-code in Algorithm 1). We consider domains with a finite action space, and say that the policy π i r is certain at state s if its action a i ∼ π i r ( a | s ) is in consensus with the ensemble: a i = a j for the majority of k out of m , where k is a hyperparameter of our algorithm. When the networks { π j r } j m =1 are not in consensus, the agent π takes a sequence of n π H actions from the entropy maximization policy π H , which encourages exploratory behavior.

Agent meta-stability Switching between two policies may result in a case where the agent repeatedly toggles between two states-if, say, the maxEnt policy takes the agent from state s 1 to a state s 2 , where the ensemble agrees on an action that again moves to state s 1 . To avoid such 'meta-stable' behavior, we randomly choose the number of maxEnt steps n π H from a Geometric distribution, n π H ∼ Geom ( α ) .

6 Experiments

We evaluate our algorithm on the ProcGen benchmark, which employs a discrete 15-dimensional action space and generates RGB observations of size 64 × 64 × 3 . Our experimental setup follows ProcGen's 'easy' configuration, wherein agents are trained on 200 levels for 25 M steps and subsequently tested on random levels [Cobbe et al., 2020]. All agents are implemented using the IMPALA convolutional architecture [Espeholt et al., 2018], and trained using PPO [Schulman et al., 2017] or

0

2

4

Step

1e7

0

2

4

6

8

10

Test Score

=0.5

=0.1

=0.3

=0.5

=0.7

=0.9

PPO

ExpGen

0

2

4

Step

1e7

0

2

4

6

8

10

=0.9

=0.1

=0.3

=0.5

=0.7

=0.9

PPO

ExpGen

0

2

4

Step

1e7

0

2

4

6

8

10

=0.99

=0.1

=0.3

=0.5

=0.7

=0.9

PPO

ExpGen

IDAAC [Raileanu and Fergus, 2021]. For the maximum entropy agent π H we incorporate a single GRU [Cho et al., 2014] at the final embedding of the IMPALA convolutional architecture. For all games, we use the same parameter α = 0 . 5 of the Geometric distribution and form an ensemble of 10 networks. For further information regarding our experimental setup and specific hyperparameters, please refer to Appendix C.

6.1 Generalization Performance

We compare our algorithm to six leading algorithms: vanilla PPO [Schulman et al., 2017], PLR [Jiang et al., 2021] that utilizes automatic curriculum-based learning, UCB-DrAC [Raileanu et al., 2021], which incorporates data augmentation to learn policies invariant to different input transformations, PPG [Cobbe et al., 2021], which decouples the optimization of policy and value function during learning, and IDAAC [Raileanu and Fergus, 2021], the previous state-of-the-art algorithm on ProcGen that decouples policy learning from value function learning and employs adversarial loss to enforce invariance to spurious features. Lastly, we evaluate our algorithm against LEEP [Ghosh et al., 2021], the only algorithm that, to our knowledge, managed to improve upon the performance of vanilla PPO on Maze and Heist. The evaluation matches the train and test setting detailed by the contending algorithms and their performance is provided as reported by their authors. For evaluating LEEP and IDAAC, we use the original implementation provided by the authors. 5

Tables 2 and 1 show the train and test scores, respectively, for all ProcGen games. The tables show that ExpGen combined with PPO achieves a notable gain over the baselines on Maze, Heist and Jumper, while on other games, invariance-based approaches perform better (for example, IDAAC leads on BigFish, Plunder and Climber, whereas PPG leads on CaveFlyer, and UCB-DrAC leads on Dodgeball). These results correspond to our observation that for some domains, invariance cannot be used to completely resolve epistemic uncertainty. We emphasize that ExpGen substantially outperforms LEEP on all games , showing that our improved exploration at test time is significant. In Appendix E we compare ExpGen with LEEP trained for 50 M environment steps, showing a similar trend. When combining ExpGen with the leading invariance-based approach, IDAAC, we establish that ExpGen is in-fact complementary to the advantage of such algorithms, setting a new state-of-the-art performance in ProcGen. A notable exception is Dodgeball, where all current methods still fail.

Figures 6 and 7 show aggregate statistics of ExpGen, PPO, PLR, UCB-DrAC, PPG and IDAAC for all games 6 , affirming the dominance of ExpGen+IDAAC as the state-of-the-art. The results are obtained using 10 runs per game, with scores normalized as in Appendix C.1. The shaded regions indicate 95% Confidence Intervals (CIs) and are estimated using the percentile stratified bootstrap with 2 , 000 (Fig. 6) and 50 , 000 (Fig. 7) bootstrap re-samples. Fig. 6 (Left) compares algorithm score-distribution, illustrating the advantage of the proposed approach across all games. Fig. 6 (Right)

0.0

0.2

0.4

0.6

0.8

1.0

Min-Max Normalized Test Score (

)

0.00

0.25

0.50

0.75

1.00

Fraction of runs with score  >

PPO

UCB-DrAC

PLR

PPG

IDAAC

ExpGen-IDAAC

0.5

0.6

0.7

0.8

0.9

1.0

P(X > Y)

IDAAC

IDAAC

IDAAC

ExpGen-IDAAC

ExpGen-IDAAC

ExpGen-IDAAC

ExpGen-IDAAC

PPO

UCB-DrAC

PPG

PPO

UCB-DrAC

PPG

IDAAC

shows the probability of improvement of algorithm X against algorithm Y . The first row (ExpGen vs. IDAAC) demonstrates that the proposed approach surpasses IDAAC with probability 0 . 6 and subsequent rows emphasize the superiority of ExpGen over contending methods at an even higher probability. This is because ExpGen improves upon IDAAC in several key challenging tasks and is on-par in the rest. Fig. 7 provides aggregate metrics of mean, median and IQM scores and optimality gap (as 1 -mean ) for all ProcGen games. The figure shows that ExpGen outperforms the contending methods in all measures.

Ablation Study One may wonder if the ensemble in ExpGen is necessary, or whether the observation that the maxEnt policy generalizes well can be exploited using a single policy. We investigate the effect of combining the intrinsic and extrinsic rewards, r I and r ext , respectively, into a single reward as a weighted sum:

and train for β = { 0 . 1 , 0 . 3 , 0 . 5 , 0 . 7 , 0 . 9 } on Maze. Figure 5 shows the train and test scores over 50 M steps for different values of discount factor γ . We obtain the best test score for γ = 0 . 5 and β = 0 . 1 , illustrating an improvement compared with the PPO baseline. When comparing with ExpGen, the combined reward (Eq. 9) exhibits inferior performance with slightly higher variance. In Appendix C.2 and F, we also provide an ablation study of ensemble size and draw comparisons to variants of our algorithm.

0.3

0.4

0.5

0.6

PPO

UCB-DrAC

PLR

PPG

IDAAC

ExpGen-IDAAC

Median

0.3

0.4

0.5

0.6

IQM

0.4

0.5

0.6

Mean

0.4

0.5

0.6

0.7

Optimality Gap

Min-Max Normalized Test Score

7 Discussion and Limitations

We observed that policies trained to explore, using maximum entropy RL, exhibited generalization of their exploration behavior in the zero-shot RL setting. Based on this insight, we proposed ExpGen-a ZSG-RL algorithm that takes a maxEnt exploration step whenever an ensemble of policies trained for reward maximization does not agree on the current action. We demonstrated that this simple approach performs well on all ZSG-RL domains of the ProcGen benchmark.

One burning question is why does maxEnt exploration generalize so well? An intuitive argument is that the maxEnt policy in an MDP is invariant to the reward. Thus, if for every training MDP there are many different rewards, each prescribing a different behavior, the maxEnt policy has to be invariant to this variability. In other words, the maxEnt policy contains no information about the rewards in the data, and generalization is well known to be bounded by the mutual information between the policy and the training data [Bassily et al., 2018]. Perhaps an even more interesting question is whether the maxEnt policy is also less sensitive to variations in the dynamics of the MDPs. We leave this as an open theoretical problem.

Another consideration is safety. In some domains, a wrong action can lead to a disaster, and in such cases, exploration at test time should be hedged. One possibility is to add to ExpGen's policy ensemble an ensemble of advantage functions, and use it to weigh the action agreement [Rotman et al., 2020]. Intuitively, the ensemble should agree that unsafe actions have a low advantage, and not select them at test time.

Finally, we point out that while our work made significant progress on generalization in several ProcGen games, the performance on Dodgeball remains low for all methods we are aware of. An interesting question is whether performance on Dodgeball can be improved by combining invariancebased techniques (other than IDAAC) with exploration at test time, or whether Dodgeball represents a different class of problems that requires a completely different approach.

Acknowledgments The research of DS was Funded by the European Union (ERC, A-B-C-Deep, 101039436). The research of EZ and AT was Funded by the European Union (ERC, Bayes-RL, 101041250). Views and opinions expressed are however those of the author(s) only and do not necessarily reflect those of the European Union or the European Research Council Executive Agency (ERCEA). Neither the European Union nor the granting authority can be held responsible for them. DS also acknowledges the support of the Schmidt Career Advancement Chair in AI.

References

Rishabh Agarwal, Max Schwarzer, Pablo Samuel Castro, Aaron C Courville, and Marc Bellemare. Deep reinforcement learning at the edge of the statistical precipice. Advances in neural information processing systems , 34:29304-29320, 2021.

Raef Bassily, Shay Moran, Ido Nachum, Jonathan Shafer, and Amir Yehudayoff. Learners that use little information. In Algorithmic Learning Theory , pages 25-55. PMLR, 2018.

Jan Beirlant, Edward J Dudewicz, László Györfi, Edward C Van der Meulen, et al. Nonparametric entropy estimation: An overview. International Journal of Mathematical and Statistical Sciences , 6(1):17-39, 1997.

Martin Bertran, Natalia Martinez, Mariano Phielipp, and Guillermo Sapiro. Instance-based generalization in reinforcement learning. Advances in Neural Information Processing Systems , 33: 11333-11344, 2020.

Dimitri Bertsekas. Dynamic programming and optimal control: Volume I , volume 1. Athena scientific, 2012.

Craig Boutilier, Chih-wei Hsu, Branislav Kveton, Martin Mladenov, Csaba Szepesvari, and Manzil Zaheer. Differentiable meta-learning of bandit policies. Advances in Neural Information Processing Systems , 33, 2020.

Kyunghyun Cho, Bart Van Merriënboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259 , 2014.

Karl Cobbe, Oleg Klimov, Chris Hesse, Taehoon Kim, and John Schulman. Quantifying generalization in reinforcement learning. In International Conference on Machine Learning , pages 1282-1289. PMLR, 2019.

Karl Cobbe, Chris Hesse, Jacob Hilton, and John Schulman. Leveraging procedural generation to benchmark reinforcement learning. In International conference on machine learning , pages 2048-2056. PMLR, 2020.

Karl W Cobbe, Jacob Hilton, Oleg Klimov, and John Schulman. Phasic policy gradient. In International Conference on Machine Learning , pages 2020-2027. PMLR, 2021.

Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Vlad Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. In International conference on machine learning , pages 1407-1416. PMLR, 2018.

Jesse Farebrother, Marlos C Machado, and Michael Bowling. Generalization and regularization in dqn. arXiv preprint arXiv:1810.00123 , 2018.

Dibya Ghosh, Jad Rahme, Aviral Kumar, Amy Zhang, Ryan P Adams, and Sergey Levine. Why generalization in rl is difficult: Epistemic pomdps and implicit partial observability. Advances in Neural Information Processing Systems , 34:25502-25515, 2021.

Elad Hazan, Sham Kakade, Karan Singh, and Abby Van Soest. Provably efficient maximum entropy exploration. In International Conference on Machine Learning , pages 2681-2691. PMLR, 2019.

YF Hendrawan. Comparison of hand follower and dead-end filler algorithm in solving perfect mazes. In Journal of Physics: Conference Series , volume 1569, page 022059. IOP Publishing, 2020.

Todd Hester and Peter Stone. Texplore: real-time sample-efficient reinforcement learning for robots. Machine learning , 90:385-429, 2013.

Maximilian Igl, Kamil Ciosek, Yingzhen Li, Sebastian Tschiatschek, Cheng Zhang, Sam Devlin, and Katja Hofmann. Generalization in reinforcement learning with selective noise injection and information bottleneck. Advances in neural information processing systems , 32, 2019.

Maximilian Igl, Gregory Farquhar, Jelena Luketina, Wendelin Boehmer, and Shimon Whiteson. The impact of non-stationarity on generalisation in deep reinforcement learning. arXiv preprint arXiv:2006.05826 , 2020.

Minqi Jiang, Edward Grefenstette, and Tim Rocktäschel. Prioritized level replay. In International Conference on Machine Learning , pages 4940-4950. PMLR, 2021.

Ken Kansky, Tom Silver, David A Mély, Mohamed Eldawy, Miguel Lázaro-Gredilla, Xinghua Lou, Nimrod Dorfman, Szymon Sidor, Scott Phoenix, and Dileep George. Schema networks: Zero-shot transfer with a generative causal model of intuitive physics. In International conference on machine learning , pages 1809-1818. PMLR, 2017.

Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine learning , 49(2):209-232, 2002.

Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980 , 2014.

Robert Kirk, Amy Zhang, Edward Grefenstette, and Tim Rocktäschel. A survey of generalisation in deep reinforcement learning. arXiv preprint arXiv:2111.09794 , 2021.

Ilya Kostrikov, Denis Yarats, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649 , 2020.

Kimin Lee, Kibok Lee, Jinwoo Shin, and Honglak Lee. Network randomization: A simple technique for generalization in deep reinforcement learning. arXiv preprint arXiv:1910.05396 , 2019a.

Lisa Lee, Benjamin Eysenbach, Emilio Parisotto, Eric Xing, Sergey Levine, and Ruslan Salakhutdinov. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274 , 2019b.

Bonnie Li, Vincent François-Lavet, Thang Doan, and Joelle Pineau. Domain adversarial reinforcement learning. arXiv preprint arXiv:2102.07097 , 2021.

Hao Liu and Pieter Abbeel. Aps: Active pretraining with successor features. In International Conference on Machine Learning , pages 6736-6747. PMLR, 2021a.

Hao Liu and Pieter Abbeel. Behavior from the void: Unsupervised active pre-training. Advances in Neural Information Processing Systems , 34:18459-18473, 2021b.

Bogdan Mazoure, Remi Tachet des Combes, Thang Long Doan, Philip Bachman, and R Devon Hjelm. Deep reinforcement and infomax learning. Advances in Neural Information Processing Systems , 33:3686-3698, 2020.

Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. nature , 518(7540):529-533, 2015.

Mirco Mutti and Marcello Restelli. An intrinsically-motivated approach for learning highly exploring and fast mixing policies. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 34, pages 5232-5239, 2020.

Mirco Mutti, Lorenzo Pratissoli, and Marcello Restelli. Task-agnostic exploration via policy gradient of a non-parametric state entropy estimate. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 35, pages 9028-9036, 2021.

Mirco Mutti, Riccardo De Santi, and Marcello Restelli. The importance of non-markovianity in maximum state entropy exploration. arXiv preprint arXiv:2202.03060 , 2022.

Roberta Raileanu and Rob Fergus. Decoupling value and policy for generalization in reinforcement learning. In International Conference on Machine Learning , pages 8787-8798. PMLR, 2021.

Roberta Raileanu, Maxwell Goldstein, Denis Yarats, Ilya Kostrikov, and Rob Fergus. Automatic data augmentation for generalization in reinforcement learning. Advances in Neural Information Processing Systems , 34:5402-5415, 2021.

Or Rivlin, Tamir Hazan, and Erez Karpas. Generalized planning with deep reinforcement learning. arXiv preprint arXiv:2005.02305 , 2020.

Noga H Rotman, Michael Schapira, and Aviv Tamar. Online safety assurance for learning-augmented systems. In Proceedings of the 19th ACM Workshop on Hot Topics in Networks , pages 88-95, 2020.

Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, et al. Mastering atari, go, chess and shogi by planning with a learned model. Nature , 588(7839):604-609, 2020.

John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347 , 2017.

Younggyo Seo, Lili Chen, Jinwoo Shin, Honglak Lee, Pieter Abbeel, and Kimin Lee. State entropy maximization with random encoders for efficient exploration. In International Conference on Machine Learning , pages 9443-9454. PMLR, 2021.

Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: From theory to algorithms . Cambridge university press, 2014.

Harshinder Singh, Neeraj Misra, Vladimir Hnizdo, Adam Fedorowicz, and Eugene Demchuk. Nearest neighbor estimates of entropy. American journal of mathematical and management sciences , 23 (3-4):301-321, 2003.

Anoopkumar Sonar, Vincent Pacelli, and Anirudha Majumdar. Invariant policy optimization: Towards stronger generalization in reinforcement learning. In Learning for Dynamics and Control , pages 21-33. PMLR, 2021.

Adam Stooke, Kimin Lee, Pieter Abbeel, and Michael Laskin. Decoupling representation learning from reinforcement learning. In International Conference on Machine Learning , pages 9870-9879. PMLR, 2021.

Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. Advances in neural information processing systems , 29, 2016.

Aviv Tamar, Daniel Soudry, and Ev Zisselman. Regularization guarantees generalization in bayesian reinforcement learning through algorithmic stability. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 36, pages 8423-8431, 2022.

Sam Toyer, Felipe Trevizan, Sylvie Thiébaux, and Lexing Xie. Action schema networks: Generalised policies with deep learning. In Thirty-Second AAAI Conference on Artificial Intelligence , 2018.

Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature , 575(7782):350-354, 2019.

Marin Vlastelica, Michal Rolínek, and Georg Martius. Neuro-algorithmic policies enable fast combinatorial generalization. arXiv preprint arXiv:2102.07456 , 2021.

Kaixin Wang, Bingyi Kang, Jie Shao, and Jiashi Feng. Improving generalization in reinforcement learning with mixture regularization. Advances in Neural Information Processing Systems , 33: 7968-7978, 2020.

Peter R Wurman, Samuel Barrett, Kenta Kawamoto, James MacGlashan, Kaushik Subramanian, Thomas J Walsh, Roberto Capobianco, Alisa Devlic, Franziska Eckert, Florian Fuchs, et al. Outracing champion gran turismo drivers with deep reinforcement learning. Nature , 602(7896): 223-228, 2022.

Huaxiu Yao, Linjun Zhang, and Chelsea Finn. Meta-learning with fewer tasks through task interpolation. arXiv preprint arXiv:2106.02695 , 2021.

Denis Yarats, Rob Fergus, Alessandro Lazaric, and Lerrel Pinto. Reinforcement learning with prototypical representations. In International Conference on Machine Learning , pages 1192011931. PMLR, 2021.

Chang Ye, Ahmed Khalifa, Philip Bontrager, and Julian Togelius. Rotation, translation, and cropping for zero-shot generalization. In 2020 IEEE Conference on Games (CoG) , pages 57-64. IEEE, 2020.

A Hidden Maze Experiment

In this section we empirically validate our thought experiment described in the Introduction: we train a recurrent policy on hidden mazes using 128 training levels (with fixed environment colors). Figure 8a depicts the observations of an agent along its trajectory; the agent sees only its own location (green spot), whereas the entire maze layout, corridors and goal, are hidden. In Fig. 8b we visualize the full, unobserved, state of the agent. The train and test results are shown in Fig 9, indicating severe overfitting to the training levels: test performance failed to improve beyond the random initial policy during training. Indeed, the recurrent policy memorizes the agent's training trajectories instead of learning generalized behavior. Hiding the maze's goal and corridors leads to agent-behavior that is the most invariant to instance specific observations-the observations include the minimum information, such that the agent can still learn to solve the maze.

t = 0

t = 1

t = 2

t = 4

t = 6

t = 9

t = 11

t = 12

t = 0

t = 1

t = 2

t = 4

t = 6

t = 9

t = 11

t = 12

Figure 8: Hidden Maze experiment where the agent only observes its own location (green spot). Both the goal (purple spot) and corridors are not observable (appear as walls).

This experiment demonstrates why methods based on observation invariance (e.g., IDAAC Raileanu and Fergus [2021]) do not improve performance on Maze-like tasks, despite significantly improving performance on games such as BigFish and Plunder, where invariance to colors helps to generalize.

0

2

4

Step

1e7

4

6

8

10

Score

Hidden Maze Experiment

Train

Test

B Maximum Entropy Policy

This section elaborates on the implementation details of the maxEnt oracle and provides a performance evaluation of the maxEnt policy.

B.1 Generalization Gap of maxEnt vs PPO across all ProcGen Environments

Recall from Section 4.2 that the (normalized) generalization gap is described by

where R emp ( π ) = R train ( π ) and R pop ( π ) = R test ( π ) . Fig 10 shows the generalization ability of the maxEnt exploration policy compared to PPO, obtained from training on 200 training levels.

BigFish

StarPilot

FruitBot

BossFight

Ninja

Plunder

CaveFlyer

CoinRun

Jumper

Chaser

Dodgeball

Heist

Leaper

Maze

Miner

0

10

20

30

40

50

60

70

Generalization Gap [%] of Maximum Entropy Policy (lower is better)

PPO Gap [%]

The figure demonstrates that the maxEnt exploration policies transfer better in zero-shot generalization (achieve a smaller generalization gap) across all ProcGen games apart from Ninja. This holds true

even in environments where the ExpGen algorithm is on par but does not exceed the baseline, pointing to the importance of exploratory behavior in some environments, but not in others.

B.2 Computing the maxEnt Oracle

The maxEnt oracle prescribes the maximum intrinsic return achievable per environment instance. To simplify the computation of the maxEnt oracle score, in this section, we evaluate the maxEnt score using the L 0 instead of the L 2 norm and use the first nearest neighbor ( k = 1 ). In Maze, we implement the oracle using the right-hand rule [Hendrawan, 2020] for maze exploration: If there is no wall and no goal on the right, the agent turns right, otherwise, it continues straight. If there is a wall (or goal) ahead, it goes left (see Figure 3). In Jumper, we first down-sample (by average pooling) from 64 × 64 to 21 × 21 pixels to form cells of 3 × 3 , and the oracle score is the number of background cells (cells that the agent can visit). Here we assume that the agent has a size of 3 × 3 pixels. In Miner, the 'easy' environment is partitioned into 10 × 10 cells. The maximum entropy is the number of cells that contain 'dirt' (i.e., cells that the agent can excavate in order to make traversable).

200

500

1000

5000

# Levels

0.0

0.2

0.4

0.6

0.8

1.0

Maze

Train with GPU

Test with GRU

Train without GRU

Test without GRU

200

500

1000

5000

# Levels

0.0

0.2

0.4

0.6

0.8

1.0

Jumper

200

500

1000

5000

# Levels

0.0

0.2

0.4

0.6

0.8

1.0

Miner

200

500

1000

5000

# Levels

0.0

0.2

0.4

0.6

0.8

1.0

Success Rate

Maze

200

500

1000

5000

# Levels

0.0

0.2

0.4

0.6

0.8

1.0

Success Rate

Jumper

200

500

1000

5000

# Levels

0.0

0.2

0.4

0.6

0.8

1.0

Success Rate

Miner

(a) Entropy Reward

200

500

1000

5000

# Levels

0

2

4

6

8

10

Score

Maze

200

500

1000

5000

# Levels

0

2

4

6

8

10

Score

Jumper

200

500

1000

5000

# Levels

0

2

4

6

8

10

12

Score

Miner

(b) Extrinsic Reward

In Fig. 11a the top row describes the intrinsic return of the maxEnt policy, normalized by the oracle's return (described above). We draw a comparison between agents with memory (GRU) and without. For the Maze environment (top-right), the agent achieves over 90% of the oracle's performance when employing a memory unit (GRU). For the Jumper and Miner environments, the agents approach 60% and 80% of the oracle's score, respectively.

Next, the bottom row of Fig. 11a details the success rate as the ratio of instances in which the agent successfully reached the oracle's score (meaning that the entire traversable region has been explored). For the Maze environment, the agent achieves a success-rate of 70% , whereas for the Jumper and Miner the agent fails to meet the oracle's score. This indicates that the oracle, as per our implementation for Jumper and Miner, captures states that are in-effect unreachable, and thus the agent is unable to match the oracle's score.

B.3 The Importance of a Memory Unit for maxEnt

We evaluate the importance of memory for maxEnt: In Fig. 11a we train a maxEnt agent with and without memory (GRU). The results indicate that for Maze, the GRU is vital in order to maximize performance for all various sizes of training set. In Jumper, we see that the GRU provides an advantage when training on 200 levels, however the benefit diminishes when additional training levels are available. For Miner, there appears to be no significant advantage for incorporating memory with 200 training levels. However, the benefit of a GRU becomes noticeable once more training levels are available (beyond 500 ).

When looking at the extrinsic reward (Fig. 11b), we see an interesting effect after introducing a GRU. Maze and Jumper suffer a degradation in performance with 200 levels (indicating overfit), while Miner appears to be unaffected.

In summary, we empirically show that memory is beneficial for the maxEnt policy on Maze, Jumper and Miner. Interestingly, we demonstrate that the introduction of memory for training to maximize extrinsic reward causes the agent to overfit in Maze and Jumper with 200 training levels.

C Experimental Setup

This section describes the constants and hyperparameters used as part of the evaluation of our algorithm.

C.1 Normalization Constants

In Figures 2 and 12 we compare the performance of the various algorithms. The results are normalized in accordance with [Cobbe et al., 2020], which defines the normalized return as

The R min and R max of each environment are detailed in Table 3. Note that the test performance of PPO on Heist (see Fig. 2) is lower than R min (the trivial performance), indicating severe overfitting.

C.2 Hyperparameters

As described in Section 5.1, the hyperparameters of our algorithm are the number of agents m that form the ensemble, of which k agents are required to be in agreement for the ensemble to achieve a consensus on its action, and α as the parameter of n π H ∼ Geom ( α ) that represents the number of maxEnt steps taken when the ensemble fails to reach a consensus. An additional hyperparameter is the neighborhood size k NN of the k -NN estimator (Section 4.1), used to determine the reward of the maxEnt policy.

We conducted a hyperparameter search over the ensemble size m ∈ { 4 , 6 , 8 , 10 } for different values of ensemble agreement k ∈ { 2 , 4 , 6 , 8 } , and values of α ∈ { 0 . 2 , 0 . 5 , 0 . 8 } . We found that a value of α = 0 . 5 , and an ensemble size of m = 10 produce the best results for all games, whereas the value of k varies from game to game, as detailed in table 4. For example, table 5 shows the results for varying values of m and k for the Maze environment. Throughout our experiments, we train our networks using the Adam optimizer [Kingma and Ba, 2014]. For the PPO hyperparameters we use the hyperparameters found in [Cobbe et al., 2020] as detailed in Table 6.

Table 7 shows an evaluation of the maxEnt gap and ExpGen using different neighbor size k NN on the Maze environment. We found that the best performance is obtained for k NN ∈ { 1 , 2 , 3 , 4 , 5 } . Thus, we choose k NN = 2 , the second nearest neighbor, for all games.

D Results for all ProcGen Games

Figure 12 details the normalized test performance for all ProcGen games. Normalization is performed according to [Cobbe et al., 2020] as described in Appendix C.1. The figure demonstrates

that ExpGen establishes state-of-the-art results on several challenging games and achieves on-par performance with the leading approach on the remaining games.

E Results after convergence

Tables 8 and 9 detail the train and test performance of ExpGen, LEEP and PPO, when trained for 50 M environment steps. Table 9 shows that ExpGen surpasses LEEP and PPO in most games.

CoinRun

StarPilot

CaveFlyer

Dodgeball

FruitBot

Chaser

Miner

Jumper

Leaper

Maze

BigFish

Heist

Plunder

Ninja

BossFight

0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

Normalized test performance on all ProcGen games

PPO

IDAAC

ExpGen+IDAAC

F Ablation Study

In the following sections, we provide ablation studies of an ExpGen variant that combines random actions and an evaluation of L 0 state similarity measure.

F.1 Ensemble Combined with Random Actions

We compare the proposed approach to a variant of ExpGen denoted by Ensemble+random where we train an ensemble and at test time select a random action if the ensemble networks fail to reach a consensus. The results are shown in Table 10, indicating that selecting the maximum entropy policy upon ensemble disagreements yields superior results.

F.2 Evaluation of Various Similarity Measures for maxEnt

Tables 11 and 12 present the results of our evaluation of ExpGen equipped with a maxEnt exploration policy that uses either the L 0 or L 2 norms. The experiment targets the Maze and Heist environments and uses the same train and test procedures as in the main paper ( 25 M training steps, score mean and standard deviation are measured over 10 seeds).

The results demonstrate that both L 2 and L 0 allow ExpGen to surpass the PPO baseline for Maze and Heist environments, in which they perform similarly well at test time. This indicates that both are valid measures of state similarity for the maxEnt policy.

G Sample Complexity

One may wonder whether the leading approaches would benefit from training on additional environment steps. A trained agent can still fail at test time either due to poor generalization performance (overfitting on a small number of training domains) or due to insufficient training steps of the policy (underfitting). In this work, we are interested in the former and design our experiments such that no method underfits. Figure 13 shows IDAAC training for 100 M steps on Maze and Jumper, illustrating that the best test performance is obtained at around 25 M steps, and training for longer does not contribute further (and can even degrade performance). Therefore, although ExpGen requires more environment steps (on account of training its ensemble of constituent reward policies), training for longer does not place our baseline (IDAAC) at any sort of a disadvantage.

Maze 100M steps (IDAAC)

Maze 100M steps (IDAAC)

10

10

8

8

Score

6

6

4

4

test mean

2

test median

2

train mean

trainmedian

0

0.00

0.25

0.50

0.75

1.00

0.00

0.25

0.50

0.75

1.00

1e8

1e8

Jumper 100M steps(IDAAC)

10

10

8

8

Score

6

6

4

4

test mean

2

test median

2

trainmean

trainmedian

0

0.00

0.25

0.50

0.75

1.00

0.00

0.25

0.50

0.75

1.00

1e8

1e8

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\n---\nI have raised my score based on the answers and results provided by the authors during the rebuttal. \n\n---\nThis paper proposes an algorithm named ExpGen that can selectively exhibit a maximum entropy exploration behavior at test time by measuring epistemic uncertainty through ensemble of policies. In order to obtain a policy trained to maximize the entropy, the entropy is formulated as an intrinsic reward, where the sample based approximation to state distribution entropy is obtained using a trajectory of states are used as neighbors. The experimental results show that ExpGen is able to achieve highest score in two of the five ProcGen environments used in the paper, namely, Maze and Heist.\n\nSTRENGTHS:\nThe paper proposes novel framework that combines the idea of switching strategies based on the epistemic uncertainty and leveraging the maximum entropy policy to bridge the gap between the performances during train and test time.\n\nWEAKNESSES:\nSome parts of the logic are unclear and there are few typos and mistakes in the paper. The experimental draws some what countering argument against the motivation of using the general framework instead of ones based on inductive biases, e.g., IDAAC. This naturally leads to combination of IDAAC and ExpGen, but is mentioned in the paper, but not experimented. Another weakness would be the memory and computational inefficiency, resulting from needing to train and inferencing ensemble of policies. Finally, the empirical studies does not draw a clear picture of why and how ExpGen works, i.e., most results are observed performances of the comprehensive algorithm, lacking a detailed ablation of each components of the algorithm.\n\nQUESTIONS:\n- Why is $k$=1 a good choice (neighbor size)? From the formulation, it seems having just one sample would have a large bias, and thus more samples would lead to better performance.\n- The variable $k$ is used twice to represent the majority volume in ensemble. The values seem to largely vary from task to task. Was there a pattern or intuition behind selecting a good candidate for a given task?\n- Using difference in RGB images as the difference in states does not quite make sense. Since states within the same trajectory are treated as nearest neighbors, I do not see a clear connection between states that are close in time and close in image space. Shouldn't two have a correlation in order for the entropy estimation to make sense? For example, it would make more sense if the observations are mapped to an embedding space that clusters temporally near states and the embeddings are used to calculate the L2 norm between states.\n- Considering the computational burden of training ensemble of policies, calculating L2 distance between two images of size 64x64x3 does not seem like a much of a burden. Was there a large time gap when full original image size was used? How does the performance differ when the original image is used versus different down sampling strategies?\n- is $i$ randomly selected?\n- Regarding the experiment done in Figure 5, expanding the observed pattern, it seems that lower $\\gamma$ and lower $\\beta$ may enable PPO to achieve a score similar to ExpGen. Is there an ablation of such?\n- While the algorithm is designed upon the idea of preference of generalizing over different tasks (as described  by $\\mathcal{L}_{emp}$) compared to inductive biases, the experimental results does not seem to reflect this argument as the performance increase is seen only in a small subset of evaluation tasks. \n- As mentioned in 6.1, is there a result of using IDAAC as the base model for ExpGen?\n\nMinor remarks.\n- In Equation 5, it is not specified how and where $x_i$ is sampled from.\n- Figure 6, legend labels GPU, which should be GRU\n- Reference section is missing in the paper (but included in supplementary)\n\nLIMITATIONS:\nAlthough limitations are included as part of the discussion, some clear limitation could be directly stated, which should help making a clear distinction of ExpGen to other algorithms. For example, comparing memory and computational efficiency against using designs like PPO with extrinsic and intrinsic reward instead of ExpGen with ensemble.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-04"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper is based upon the key insight, that maxEnt exploratory policies exhibit a much smaller generalization gap than usual reward seeking policies.\nPrevious work introduced the framework of epistemic POMDPs, where a random action is chosen until the uncertainty of the policy is low enough again (quantified by policy ensemble members that agree or disagree).\nThe paper improves upon the previous work by using the maxEnt exploratory policy instead of the random policy when policy ensemble members disagree.\nThis allows to substantially improve generalization performance on ProcGen tasks previous methods fail on (Maze and Heist).\n\nSTRENGTHS:\n- Very well written introduction and related work.\n- Well executed idea to improve weaknesses of previous state-of-the-art algorithm for specific generalization problems of the ProcGen suite.\n- Interesting and well executed empirical investigation.\n\nWEAKNESSES:\n**Major Weaknesses**\n\n- The usage of L0 norm instead of L2 norm in Eq. (8) is not justified, as to the best of our knowledge, the (log of the) k-NN distance does not approximate the entropy under this norm, but only under the euclidean (L2) norm. Therefore, maximising Eq. (8) might not yield a maxEnt policy.\n- Evaluation protocol of main experiments is not clear (see questions).\n\n**Minor Weaknesses**\n\n- In line 72 / 73, it is stated that the exploration policy is GUARANTEED to generalize. The paper does not contain a formal proof, but rather an empirical investigation, therefore this claim should be down-toned to reflect this correctly.\n\n**Remarks**\n\n- Please check the citation style again, often \\cite is used instead of \\citep.\n- Use \\eqref to reference equations.\n- Check notation (e.g. the true state as part of the history in line 128)\n\nQUESTIONS:\n- How do you select the k-NN? Is it also done using the L0 norm?\n- What is your hypothesis why the L0 works better?\n- How is it justified to use the L0 norm instead of the L2 norm for the k-NN entropy estimator? I.e. the particle based derivation will not work out.\n- The main point of the paper is, that maxEnt exploration policies transfer better in zero-shot generalization. This should be true irrespective of the final performance.\nThe investigation of this property (Fig. 3 and 6) therefore seems limited, as those are the environments the algorithm actually improves most on. I would raise my score, if the same evaluation could be provided for all environments investigated in the main experiments to get a better view of the empirical significance of this finding.\n- How are scores of the main experiments in table 1 and 2 computed?\n\nLIMITATIONS:\nThe authors openly discuss limitations of their approach for other environments of the ProcGen suite, which are better suited for different algorithms that incorporate invariances into the trained policy.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-05"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper studies zero-shot generalization in RL. They first make an interesting observation: that intrinsic novelty-based rewards corresponding to maximum entropy exploration exhibit a smaller generalization gap than extrinsic environment rewards on ProcGen games. This suggests that MaxEnt rewards are in some sense richer and harder to memorize, and the agent is less prone to overfitting to them and more likely to generalize its exploratory behavior to new levels. The MaxEnt reward here is implemented using a kNN based method, similar to ProtoRL of Yarats et al. \n\nBased on this observation, the paper proposes a new algorithm (ExpGen), which trains a MaxEnt exploratory policy (which, as noted above, should generalize its exploratory behavior well), as well as an ensemble of K exploitation policies using the usual extrinsic reward. At test time, if the ensemble agrees on an action (indicating good generalization), then this action is executed. If not (indicating poor generalization), the exploratory policy (which is assumed to generalize well) is executed instead for a certain number of steps, and the process is repeated. \n\nThis algorithm is evaluated on the ProcGen benchmark, where it is compared to a number of other published methods (PPO, PLR, UCB-DrAC, PPG, IDAAC, LEEP). On two games (Maze and Heist), it significantly outperforms the other methods. However, it significantly underperforms in several others. \n\nOverall, this paper has several things going for it: the insight that MaxEnt reward has more favorable generalization properties is definitely interesting, and I think the ExpGen algorithm (or some variant of it) has potential. However, the experiments do not (yet) convincingly make a case for this algorithm: while it shows advantages in some games, it significantly underperforms in others and its aggregate performance does not seem favorable. This may be fixable — as the authors note, the invariances induced by other algorithms are orthogonal to the contributions of ExpGen, so I suspect the benefits could be combined. I would suggest combining the architectural modifications and auxiliary losses from IDAAC with ExpGen - if this indeed combines the best of both algorithms, the resulting method would be a lot more convincing. This is discussed in the paper, but not done, and in my opinion needs to be tested. \n\nSecond, there are a number of presentation and/or methodological issues which also need to be addressed. Please see my comments in the Weaknesses section. \n\nI think that if all these issues can be addressed, then this would make a strong submission. I think the substance of this paper is good, but it probably requires another revision cycle to be polished enough for publication. \n\n**Post rebuttal update: the authors have addressed my two main concerns. They have shown that ExpGen can be combined with IDAAC to get robust and SOTA results across all ProcGen games, and they have shown that the baselines do not improve when given a larger sample budget. Based on this, and assuming the authors will also improve the presentation as promised, I think this is now a strong submission and have raised my score to a 7 (Accept).**\n\nSTRENGTHS:\n- The paper addresses an important problem - zero-shot generalization in RL is relatively understudied compared to the singleton MDP setting, but important for many realistic settings\n- As mentioned above, the insights are original, and the algorithm (also original) follows nicely from them\n\nWEAKNESSES:\n- As mentioned above, the experiments in their current form are not convincing enough\n- There is potentially an important methodological issue which needs clearing up, namely ExpGen appears to use many more samples than the other algorithms it is compared to due to the use of several policies. \n- The presentation could be improved\n\nQUESTIONS:\nMy suggestions for improving the paper are as follows:\n\nMajor:\n\n- Try to improve the performance of ExpGen by combining it with algorithmic elements from IDAAC or other methods. As mentioned in the paper, these improvements are orthogonal so hopefully it should be possible — however, it’s not sufficient to hypothesize that the two can be combined, this needs to be validated experimentally. \n- It may be that ProcGen isn’t the best experimental testbed to showcase the strengths of the proposed algorithm (indeed, several of the games have dense rewards, and exploration bonuses can sometimes actually hurt performance in such settings). An alternative could be MiniHack (https://arxiv.org/abs/2109.13202) — these environments are also procedurally generated, and additionally for the most part have sparse rewards. You can easily replicate the current setup where there is a limited number of seeds at training, and they are also very fast to run. \n- Another potential testbed is the Habitat embodied AI environment. That has a limited number of training levels and overfitting/generalization is a severe issue. In particular, Object Navigation is currently not solvable via RL and current SOTA requires large-scale IL using expensive human demonstrations (https://arxiv.org/abs/2204.03514) (in particular, because they perform exploration which the agent also needs to do at test time). I think this could be a good fit for the proposed method, and if you could get it to work there that would be very convincing. \n- Tables 1 and 2 are hard to read due to the many environments and methods. I would suggest displaying aggregate metrics using the RLiable library (https://github.com/google-research/rliable). This will also determine if differences are statistically significant. \n- I’m concerned the comparison to baselines might not be fair. It is reported that each method trains for 25M steps. However, ExpGen trains not 1 but (K+1) policies. Are each of these trained for 25M steps, or are they trained for 25M / (K+1) steps? To fairly compare to a policy trained for 25M steps, it should be the latter. Please clarify. If each policy was trained for 25M steps, then the baselines should be trained for 25M * (K+1) steps. \n\n\n\n\nMinor:\n\n- The legend in Figure 3 is quite small and hard to find, which can make the reader confused as to what they’re looking at. I would suggest making it bigger and placing it below the subplots, instead of inside the first one. \n- The notation in Section 4.1 is confusing: specifically, the Latex rendering of “k-NN” make it look like “k minus NN”. I would suggest using “x^\\mathrm{kNN}” or something else that doesn’t use the minus sign. \n- Figure 5: it is not clear from the caption which task this is for. Please add this to the caption. \n- The references are currently missing from the main paper (although they show up in the version in the supplement), please fix.\n\nLIMITATIONS:\nYes.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis work studies generalization on unseen similar tasks, in a zero-shot manner, and discusses how invariance based approach to overfitting might not work all the time. The algorithm proposed, called ExpGen, has one part that explores the space, while a ensemble of agents are trained to do the reward optimization, and it claims to achieve sota results on ProcGen.\n\nSTRENGTHS:\n1. The paper is well written, and it introduces the problem statement and the challenges faced by the current methods well.\n2. There is a good discussion about the related work as well, which helps place the proposed method in a proper context.\n3. The set of experiments and tables are clear and the authors have given proper pointers to architecture choices and hyperparameters.\n4. The limitations section is also addressed very well. The work talks about the game of Dodgeball where all the methods suffer and some possible insights on things that could be looked into for this.\n5. The idea looks promising and can help in adding a useful contribution to the community.\n\nWEAKNESSES:\n1. Adding training progress plots can show how the evaluation scores evolved. \n2. Figure 4 is very difficult to read. It can also benefit from the more useful captions.\n3. The proposed method does not do well in all the games. Other than the invariance, is there anything else that might be a reason for this? And is there a study on improving on these games?\n4. For some baselines, the scores from the respective papers seem to have been used. It is possible the methods missed a proper hyperparameter tuning. Clarifying this in the work  and doing a proper hyperparameter search and tuning for all methods equally will be helpful.\n\nQUESTIONS:\n- Do all methods, including baselines, go through a proper hyperparameter tuning and search phase conducted by the authors?\n\nLIMITATIONS:\nThe authors do discuss the limitations in their work.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-07"}