Multi-task Deep Reinforcement Learning with PopArt

by   Matteo Hessel, et al.

The reinforcement learning community has made great strides in designing algorithms capable of exceeding human performance on specific tasks. These algorithms are mostly trained one task at the time, each new task requiring to train a brand new agent instance. This means the learning algorithm is general, but each solution is not; each agent can only solve the one task it was trained on. In this work, we study the problem of learning to master not one but multiple sequential-decision tasks at once. A general issue in multi-task learning is that a balance must be found between the needs of multiple tasks competing for the limited resources of a single learning system. Many learning algorithms can get distracted by certain tasks in the set of tasks to solve. Such tasks appear more salient to the learning process, for instance because of the density or magnitude of the in-task rewards. This causes the algorithm to focus on those salient tasks at the expense of generality. We propose to automatically adapt the contribution of each task to the agent's updates, so that all tasks have a similar impact on the learning dynamics. This resulted in state of the art performance on learning to play all games in a set of 57 diverse Atari games. Excitingly, our method learned a single trained policy - with a single set of weights - that exceeds median human performance. To our knowledge, this was the first time a single agent surpassed human-level performance on this multi-task domain. The same approach also demonstrated state of the art performance on a set of 30 tasks in the 3D reinforcement learning platform DeepMind Lab.



There are no comments yet.


page 10


Multi-task Learning and Catastrophic Forgetting in Continual Reinforcement Learning

In this paper we investigate two hypothesis regarding the use of deep re...

IMPALA: Scalable Distributed Deep-RL with Importance Weighted Actor-Learner Architectures

In this work we aim to solve a large collection of tasks using a single ...

Planner-Reasoner Inside a Multi-task Reasoning Agent

We consider the problem of multi-task reasoning (MTR), where an agent ca...

Attentive Multi-Task Deep Reinforcement Learning

Sharing knowledge between tasks is vital for efficient learning in a mul...

Modular Networks Prevent Catastrophic Interference in Model-Based Multi-Task Reinforcement Learning

In a multi-task reinforcement learning setting, the learner commonly ben...

Observe and Look Further: Achieving Consistent Performance on Atari

Despite significant advances in the field of deep Reinforcement Learning...

Accelerating Reinforcement Learning by Composing Solutions of Automatically Identified Subtasks

This paper discusses a system that accelerates reinforcement learning by...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.


In recent years, the field of deep reinforcement learning (RL) has enjoyed many successes. Deep RL agents have been applied to board games such as Go [Silver et al.2016] and chess [Silver et al.2017], continuous control [Lillicrap et al.2016, Duan et al.2016], classic video-games such as Atari [Mnih et al.2015, Hessel et al.2018, Gruslys et al.2018, Schulman et al.2015, Schulman et al.2017, Bacon, Harb, and Precup2017], and 3D first person environments [Mnih et al.2016, Jaderberg et al.2016]. While the results are impressive, they were achieved on one task at the time, each task requiring to train a new agent instance from scratch.

Multi-task and transfer learning remain important open problems in deep RL. There are at least four different strains of multi-task reinforcement learning that have been explored in the literature: off-policy learning of many predictions about the same stream of experience

[Schmidhuber1990, Sutton et al.2011, Jaderberg et al.2016], continual learning in a sequence of tasks [Ring1994, Thrun1996, Thrun2012, Rusu et al.2016], distillation of task-specific experts into a single shared model [Parisotto, Ba, and Salakhutdinov2015, Rusu et al.2015, Schmitt et al.2018, Teh et al.2017], and parallel learning of multiple tasks at once [Sharma and Ravindran2017, Caruana1998]. We will focus on the latter.

Parallel multi-task learning has recently achieved remarkable success in enabling a single system to learn a large number of diverse tasks. The Importance Weighted Actor-Learner Architecture, henceforth IMPALA [Espeholt et al.2018], achieved a 59.7% median human normalised score across 57 Atari games, and a 49.4% mean human normalised score across 30 DeepMind Lab levels. These results are state of the art for multi-task RL, but they are far from the human-level performance demonstrated by deep RL agents on the same domains, when trained on each task individually.

Part of why multi-task learning is much harder than single task learning is that a balance must be found between the needs of multiple tasks, that compete for the limited resources of a single learning system (for instance, for its limited representation capacity). We observed that the naive transposition of common RL algorithms to the multi-task setting may not perform well in this respect. More specifically, the saliency of a task for the agent increases with the scale of the returns observed in that task, and these may differ arbitrarily across tasks. This affects value-based algorithms such as Q-learning [Watkins1989], as well as policy-based algorithms such as REINFORCE [Williams1992].

The problem of scaling individual rewards appropriately is not novel, and has often been addressed through reward clipping [Mnih et al.2015]

. This heuristic changes the agent’s objective, e.g., if all rewards are non-negative the algorithm optimises

frequency of rewards rather than their cumulative sum. If the two objectives are sufficiently well aligned, clipping can be effective. However, the scale of returns also depends on the rewards’ sparsity. This implies that, even with reward clipping, in a multi-task setting the magnitude of updates can still differ significantly between tasks, causing some tasks to have a larger impact on the learning dynamics than other equally important ones.

Note that both the sparsity and the magnitude of rewards collected in an environment are inherently non-stationary, because the agent is learning to actively maximise the total amount of rewards it can collect. These non-stationary learning dynamics make it impossible to normalise the learning updates a priori, even if we would be willing to pour significant domain knowledge into the design of the algorithm.

To summarise, in IMPALA the magnitude of updates resulting from experience gathered in each environment depends on: 1) the scale of rewards, 2) the sparsity of rewards, 3) the competence of the agent. In this paper we use PopArt normalisation [van Hasselt et al.2016] to derive an actor-critic update invariant to these factors, enabling large performance improvements in parallel multi-task agents. We demonstrated this on the Atari-57 benchmark, where a single agent achieved a median normalised score of 110% and on DmLab-30, where it achieved a mean score of 72.8%.


Reinforcement learning (RL) is a framework for learning and decision-making under uncertainty [Sutton and Barto2018]. A learning system - the agent - must learn to interact with the environment it is embedded in, so as to maximise a scalar reward

signal. The RL problem is often formalised as a Markov decision process

[Bellman1957]: a tuple , where are finite sets of states and actions, denotes the dynamics, such that

is the probability of observing reward

and state when executing action in state , and discounts future rewards. The policy maps states

to probability distributions over actions

, thus specifying the behaviour of the agent. The return is the -discounted sum of rewards collected by an agent from state onward under policy . We define action values and state values as and , respectively. The agent’s objective is to find a policy to maximise such values.

In multi-task reinforcement learning, a single agent must learn to master N different environments , each with its own distinct dynamics [Brunskill and Li2013]. Particularly interesting is the case in which the action space and transition dynamics are at least partially shared. For instance, the environments might follow the same physical rules, while the set of interconnected states and obtainable rewards differ. We may formalise this as a single larger MDP, whose state space is . The task index

may be latent, or may be exposed to the agent’s policy. In this paper, we use the task index at training time, for the value estimates used to compute the policy updates, but not at testing time: our algorithm will return a single general policy

which is only function of the individual environment’s state and not conditioned directly on task index . This is more challenging than the standard multi-task learning setup, which typically allows conditioning the model on the task index even at evaluation [Romera-Paredes et al.2013, Collobert and Weston2008], because our agents will need to infer what task to solve purely from the stream of raw observations and/or early rewards in the episode.


In our experiments, we use an actor-critic algorithm to learn a policy and a value estimate

, which are both outputs of a deep neural network. We update the agent’s policy by using REINFORCE-style stochastic gradient

[Williams1992], where

is used as a baseline to reduce variance. In addition we use a multi-step return

that bootstraps on the value estimates after a limited number of transitions, both to reduce variance further and to allow us to update the policy before fully resolves at the end of an episode. The value function is instead updated to minimise the squared loss with respect to the (truncated and bootstrapped) return:


where and are stochastic estimates of and , respectively. Note how both updates depend linearly on the scale of returns, which, as previously argued, depend on scale/sparsity of rewards, and agent’s competence.

Efficient multi-task learning in simulation

We use the IMPALA agent architecture [Espeholt et al.2018], proposed for reinforcement learning in simulated environments. In IMPALA the agent is distributed across multiple threads, processes or machines. Several actors run on CPU generating rollouts of experience, consisting of a fixed number of interactions (100 in our experiments) with their own copy of the environment, and then enqueue the rollouts in a shared queue. Actors receive the latest copy of the network’s parameters from the learner before each rollout. A single GPU learner processes rollouts from all actors, in batches, and updates a deep network. The network is a deep convolutional ResNet [He et al.2015], followed by a LSTM recurrent layer [Hochreiter and Schmidhuber1997]. Policy and values are all linear functions of the LSTM’s output.

Despite the large network used for estimating policy and values , the decoupled nature of the agent enables to process data very efficiently: in the order of hundreds of thousands frames per second [Espeholt et al.2018]. The setup easily supports the multi-task setting by simply assigning different environments to each of the actors and then running the single policy on each of them. The data in the queue can also be easily labelled with the task id, if useful at training time. Note that an efficient implementation of IMPALA is available open-source, and that, while we use this agent for our experiments, our approach can be applied to other data parallel multi-task agents (e.g. A3C).

Off-policy corrections

Because we use a distributed queue-based learning setup, the data consumed by the learning algorithm might be slightly off-policy, as the policy parameters change between acting and learning. We can use importance sampling corrections to compensate for this [Precup, Sutton, and Singh2000]. In particular, we can write the -step return as where , and then apply appropriate importance sampling corrections to each error term [Sutton et al.2014] to get This is unbiased, but has high variance. To reduce variance, we can further clip most of the importance-sampling ratios, e.g., as . This leads to the -trace return [Espeholt et al.2018]


A very similar target was proposed for the ABQ() algorithm [Mahmood2017], where the product was considered and then the trace parameter was chosen to be adaptive to lead to exactly the same behaviour that . This shows that this form of clipping does not impair the validity of the off-policy corrections, in the same sense that bootstrapping in general does not change the semantics of a return. The returns used by the value and policy updates defined in Equation 1 and 2 are then


This is the same algorithm as used by Espeholt et al. (2018) in the experiments on the IMPALA architecture.

Adaptive normalisation

In this section we use PopArt normalisation [van Hasselt et al.2016], which was introduced for value-based RL, to derive a scale invariant algorithm for actor-critic agents. For simplicity, we first consider the single-task setting, then we extend it to the multi-task setting (the focus of this work).

Scale invariant updates

In order to normalise both baseline and policy gradient updates, we first parameterise the value estimate

as the linear transformation of a suitably

normalised value prediction . We further assume that the normalised value prediction is itself the output of a linear function, for instance the last fully connected layer of a deep neural net:


As proposed by van Hasselt et al., and

can be updated so as to track mean and standard deviation of the values. First and second moments of can be estimated online as


and then used to derive the estimated standard deviation as . Note that the fixed decay rate determines the horizon used to compute the statistics. We can then use the normalised value estimate and the statistics  and to normalise the actor-critic loss, both in its value and policy component; this results in the scale-invariant updates:


If we optimise the new objective naively, we are at risk of making the problem harder: the normalised targets for values are non-stationary, since they depend on statistics and . The PopArt normalisation algorithm prevents this, by updating the last layer of the normalised value network to preserve unnormalised value estimates , under any change in the statistics and :


This extends PopArt’s scale-invariant updates to the actor-critic setting, and can help to make tuning hyperparameters easier, but it is not sufficient to tackle the challenging multi-task RL setting that we are interested in this paper. For this, a single pair of normalisation statistics is not sufficient.

Scale invariant updates for multi-task learning

Let be an environment in some finite set , and let be a task-agnostic policy, that takes a state from any of the environments , and maps it to a probability distribution onto the shared action space . Consider now a multi-task value function with N outputs, one for each task. We can use for the same parametrisation as in Equation 5

, but with vectors of statistics

, and a vector-valued function


where and denote the parameters of the last fully connected layer in . Given a rollout , generated under task-agnostic policy in environment , we can adapt the updates in Equation 7 and 8 to provide scale invariant updates also in the multi-task setting:


Where the targets use the value estimates for environment for bootstrapping. For each rollout, only the head in the value net is updated, while the same policy network is updated irrespectively of the task, using the appropriate rescaling for updates to parameters . As in the single-task case, when updating the statistics and we also need to update and to preserve unnormalised outputs,


where is the row of matrix , and are the elements of the corresponding parameter vectors. Note that in all updates only the values, but not the policy, are conditioned on the task index, which ensures that the resulting agent can then be run in a fully task agnostic way, since values are only used to reduce the variance of the policy updates at training time but not needed for action selection.

Atari-57 Atari-57 (unclipped) DmLab-30
Agent Random Human Random Human Train Test
Table 1: Summary of results: aggregate scores for IMPALA and PopArt-IMPALA. We report median human normalised score for Atari-57, and mean capped human normalised score for DmLab-30. In Atari, Random and Human refer to whether the trained agent is evaluated with random or human starts. In DmLab-30 the test score includes evaluation on the held-out levels.


We evaluated our approach in two challenging multi-task benchmarks, Atari-57 and DmLab-30, based on Atari and DeepMind Lab respectively, and introduced by Espeholt et al. We also consider a new benchmark, consisting of the same games as Atari-57, but with the original unclipped rewards. We demonstrate state of the art performance on all benchmarks. To aggregate scores across many tasks, we normalise the scores on each task based on the scores of a human player and of a random agent on that same task [van Hasselt, Guez, and Silver2016]. All experiments use population-based training (PBT) to tune hyperparameters [Jaderberg et al.2017]. As in Espeholt et al., we report learning curves as function of the number of frames processed by one instance of the tuning population, summed across tasks.


Atari-57 is a collection of 57 classic Atari 2600 games. The ALE [Bellemare et al.2013], exposes them as RL environments. Most prior work has focused on training agents for individual games [Mnih et al.2015, Hessel et al.2018, Gruslys et al.2018, Schulman et al.2015, Schulman et al.2017, Bacon, Harb, and Precup2017]. Multi-task learning on this platform has not been as successful due to large number of environments, inconsistent dynamics and very different reward structure. Prior work on multi-task RL in the ALE has therefore focused on smaller subsets of games [Rusu et al.2015, Sharma and Ravindran2017]. Atari has a particularly diverse reward structure. Consequently, it is a perfect domain to fully assess how well can our agents deal with extreme differences in the scale of returns. Thus, we train all agents both with and without reward clipping, to compare performance degradation as returns get more diverse in the unclipped version of the environment. In both cases, at the end of training, we test agents both with random-starts [Mnih et al.2015] and human-starts [Nair et al.2015]; aggregate results are reported in Table 1 accordingly.

DmLab-30 is a collection of 30 visually rich, partially observable RL environments [Beattie et al.2016]. This benchmark has strong internal consistency (all levels are played with a first person camera in a 3D environment with consistent dynamics). Howevere, the tasks themselves are quite diverse, and were designed to test distinct skills in RL agents: among these navigation, memory, planning, laser-tagging, and language grounding. The levels can also differ visually in non-trivial ways, as they include both natural environments and maze-like levels. Two levels (rooms_collect_good_objects and rooms_exploit_deferred_effects) have held out test versions, therefore Table 1 reports both train and test aggregate scores. We observed that the original IMPALA agent suffers from an artificial bottleneck in performance, due to the fact that some of the tasks cannot be solved with the action set available to the agent. As first step, we thus fix this issue by equipping it with a larger action set, resulting in a stronger IMPALA baseline than reported in the original paper. We also run multiple independent PBT experiments, to assess the variability of results across multiple replications.

Atari-57 results

Figures 1 and 2 show the median human normalised performance across the entire set of 57 Atari games in the ALE, when training agent with and without reward clipping, respectively. The curves are plotted as function of the total number of frames seen by each agent.

PopArt-IMPALA (orange line) achieves a median performance of 110% with reward clipping and a median performance of 101% in the unclipped version of Atari-57. Recall that here we are measuring the median performance of a single trained agent across all games, rather than the median over the performance of a set of individually trained agents as it has been more common in the Atari domain. To our knowledge, both agents are the first to surpass median human performance across the entire set of 57 Atari games.

The IMPALA agent (blue line) performs much worse. The baseline barely reaches with reward clipping, and the median performance is close to 0% in the unclipped setup. The large decrease in the performance of the baseline IMPALA agent once clipping is removed is in stark contrast with what we observed for PopArt-IMPALA, that achieved almost the same performance in the two training regimes.

Since the level-specific value predictions used by multi-task PopArt effectively increase the capacity of the network, we also ran an additional experiment to disentangle the contribution of the increased network capacity from the contribution of the adaptive normalisation. For this purpose, we train a second baseline, that uses level specific value predictions, but does not use PopArt to adaptively normalise the learning updates. The experiments show that such MultiHead-IMPALA agent (pink line) actually performs slightly worse than the original IMPALA both with and without clipping, confirming that the performance boost of PopArt-IMPALA is indeed due to the adaptive rescaling.

We highlight that in our experiments a single instance of multi-task PopArt-IMPALA has processed the same amount of frames as a collection of 57 expert DQN agents (), while achieving better performance. Despite the large CPU requirements, on a cloud service, training multi-task PopArt-IMPALA can also be competitive in terms of costs, since it exceeds the performance of a vanilla-DQN in just 2.5 days, with a smaller GPU footprint.

Figure 1: Atari-57 (reward clipping). Median human normalised score across all Atari levels, as function of the total number of frames seen by the agents across all levels. We compare PopArt-IMPALA to IMPALA and to an additional baseline, MultiHead-IMPALA, that uses task-specific value predictions but no adaptive normalisation. All three agent are trained with the clipped reward scheme.
Figure 2: Atari-57 (unclipped): Median human normalised score across all Atari levels, as a function of the total number of frames seen by the agents across all levels. We here compare the same set of agents as in Figure 1, but now all agents are trained without using reward clipping. The approximately flat lines corresponding to the baselines mean no learning at all on at least 50% of the games.

Normalisation statistics

It is insightful to observe the different normalisation statistics across games, and how they adapt during training. Figure 3 (top row) plots the shift for a selection of Atari games, in the unclipped training regime. The scale is visualised in the same figure by shading the area in the range . The statistics differ by orders of magnitude across games: in crazy_climber the shift exceeds 2500, while in bowling it never goes above 15. The adaptivity of the proposed normalisation emerges clearly in crazy_climber and qbert, where the statistics span multiple orders of magnitude during training. The bottom row in Figure 3 shows the corresponding agent’s undiscounted episode return: it follows the same patterns as the statistics (with differences in magnitude due to discounting). Finally note how the statistics can even track the instabilities in the agent’s performance, as in qbert.

Figure 3: Normalisation statistics: Top: learned statistics, without reward clipping, for four distinct Atari games. The shaded region is . Bottom: undiscounted returns.

DmLab-30 results

Figure 4 shows, as a function of the total number of frames processed by each agent, the mean human normalised performance across all 30 DeepMind Lab levels, where each level’s score is capped at 100% . For all agents, we ran three independent PBT experiments. In Figure 4 we plot the learning curves for each experiment and, for each agent, fill in the area between best and worse experiment.

Compared to the original paper, our IMPALA baseline uses a richer action set, that includes more possible horizontal rotations, and vertical rotations (details in Appendix). Fine-grained horizontal control is useful on lasertag levels, while vertical rotations are necessary for a few psychlab levels. Note that this new baseline (solid blue in Figure 4) performs much better than the original IMPALA agent, which we also train and report for completeness (dashed blue). Including PopArt normalisation (in orange) on top of our baseline results in largely improved scores. Note how agents achieve clearly separated performance levels, with the new action set dominating the original paper’s one, and with PopArt-IMPALA dominating IMPALA for all three replications of the experiment.

Figure 4: DmLab-30. Mean capped human normalised score of IMPALA (blue) and PopArt-IMPALA (orange), across the DmLab-30 benchmark as function of the number of frames (summed across all levels). Shaded region is bounded by best and worse run among 3 PBT experiments. For reference, we also plot the performance of IMPALA with the limited action set from the original paper (dashed).
Figure 5: DmLab-30 (with pixel control). Mean capped human normalised score of PopArt-IMPALA with pixel control (red), across the DmLab-30 benchmark as function of the total number of frames across all tasks. Shaded region is bounded by best and worse run among 3 PBT experiments. Dotted lines mark the point where Pixel-PopArt-IMPALA matches PopArt-IMPALA and the two IMPALA baselines.


In this section, we explore the combination of the proposed PopArt-IMPALA agent with pixel control [Jaderberg et al.2016], to further improve data efficiency, and make training IMPALA-like agents on large multi-task benchmarks cheaper and more practical. Pixel control is an unsupervised auxiliary task introduced to help learning good state representations. As shown in Figure 5, the combination of PopArt-IMPALA with pixel control (red line) allows to match the final performance of the vanilla PopArt-IMPALA (orange line) with a fraction of the data ( frames). This is on top of the large improvement in data efficiency already provided by PopArt, meaning that the pixel control augmented PopArt-IMPALA needs less than -th of the data to match our own IMPALA baseline’s performance (and -th of the frames to match the original published IMPALA). Importantly, since both PopArt and Pixel Control only add a very small computational cost, this improvement in data efficiency directly translates in a large reduction of the cost of training IMPALA agents on large multi-task benchmarks. Note, finally, that other orthogonal advances in deep RL could also be combined to further improve performance, similarly to what was done by Rainbow [Hessel et al.2018], in the context of value-based reinforcement learning.

Implementation notes

We implemented all agents in TensorFlow. For each batch of rollouts processed by the learner, we average the

targets within a rollout, and for each rollout in the batch we perform one online update of PopArt’s normalisation statistics with decay . Note that didn’t require any tuning. To prevent numerical issues, we clip the scale in the range . We do not back-propagate gradients into and , exclusively updated as in Equation 6. The weights of the last layer of the value function are updated according to Equation 13 and 11. Note that we first apply the actor-critic updates (11), then update the statistics (6), finally apply output preserving updates (13). For more just-in-time rescaling of updates we can invert this order, but this wasn’t necessary. As anticipated, in all experiments we used population-based training (PBT) to adapt hyperparameters during training [Jaderberg et al.2017]. As in the IMPALA paper, we use PBT to tune learning_rate, entropy_cost, the optimiser’s epsilon, and—in the Atari experiments—the max_gradient_norm. In Atari-57 we used populations of 24 instances, in DmLab-30 just 8 instances. All hyperparameters are reported in the Appendix.


In this paper we propose a scale-invariant actor-critic algorithm that enables significantly improved performance in multi-task reinforcement learning settings. Being able to acquire knowledge about a wide range of facts and skills has been long considered an essential feature for an RL agent to demonstrate intelligent behaviour [Sutton et al.2011, Degris and Modayil2012, Legg and Hutter2007]. To ask our algorithms to master multiple tasks is therefore a natural step as we progress towards increasingly powerful agents.

The wide-spread adoption of deep learning in RL is quite timely in this regard, since sharing parts of a neural network across multiple tasks is also a powerful way of building robust representations. This is particularly important for RL, because rewards on individual tasks can be sparse, and therefore sharing representations across tasks can be vital to bootstrap learning. Several agents 

[Jaderberg et al.2016, Lample and Chaplot2016, Shelhamer et al.2016, Mirowski et al.2016] demonstrated this by improving performance on a single external task by learning off-policy about auxiliary tasks defined on the same stream of experience (e.g. pixel control, immediate reward prediction or auto-encoding).

Multi-task learning, as considered in this paper, where we get to execute, in parallel, the policies learned for each task, has potential additional benefits, including deep exploration [Osband et al.2016], and policy composition [Mankowitz et al.2018, Todorov2009]. By learning on-policy about tasks, it may also be easier to scale to much more diverse tasks: if we only learn about some task off-policy from experience generated pursuing a very different one, we might never observe any reward. A limitation of our approach is that it can be complicated to implement parallel learning outside of simulation, but recent work on parallel training of robots [Levine et al.2016] suggests that this is not necessarily an insurmountable obstacle if sufficient resources are available.

Adoption of parallel multi-task RL has up to now been fairly limited. That the scaling issues considered in this paper, may have been a factor in the limited adoption is indicated by the wider use of this kind of learning in supervised settings [Johnson et al.2017, Lu et al.2016, Misra et al.2016, Hashimoto et al.2016]

, where loss functions are naturally well scaled (e.g. cross entropy), or can be easily scaled thanks to the stationarity of the training distribution. We therefore hope and believe that the work presented here can enable more research on multi-task RL.

We also believe that PopArt’s adaptive normalisation can be combined with other research in multi-task reinforcement learning, that previously did not scale as effectively to large numbers of diverse tasks. We highlight as potential candidates policy distillation [Parisotto, Ba, and Salakhutdinov2015, Rusu et al.2015, Schmitt et al.2018, Teh et al.2017] and active sampling of the task distribution the agent trains on [Sharma and Ravindran2017]. The combination of PopArt-IMPALA with active sampling might be particularly promising since it may allow a more efficient use of the parallel data generation, by focusing it on the task most amenable for learning. Elastic weight consolidation [Kirkpatrick et al.2017] and other work from the continual learning literature [Ring1994, Mcclelland, Mcnaughton, and O’Reilly1995] might also be adapted to parallel learning setups to reduce interference [French1999] among tasks.



In this Appendix we report additional details about the results presented in the main text, as well as present additional experiments on the DmLab-30 benchmark. We also report the breakdown per level of the scores of IMPALA and PopArt-IMPALA on the Atari-57 and DmLab-30 benchmarks. Finally, we report the hyperparameters used to train the baseline agents as well as PopArt-IMPALA. These hyperparameters are mostly the same as in Espeholt et al., but we report them for completeness and to ease reproducibility.

Hyper-parameter tuning

In our experiments we used Population-Based Training (PBT) to tune hyper-parameters. In our DmLab-30 experiments, however, we used smaller populations than in the original IMPALA paper. For completeness, we also report here the results of running PopArt-IMPALA and IMPALA with the larger population size used by Espeholt et al. Due to the increased cost of using larger populations, in this case we will only report one PBT tuning experiment per agent, rather than the 3 reported in the main text.

The learning curves for both IMPALA and PopArt-IMPALA are shown in Figure 6, together with horizontal dashed lines marking average final performance of the agents trained with the smaller population of just 8 instances. The performance of both IMPALA and PopArt-IMPALA agents at the end of training is very similar whether hyperparameters are tuned with 8 or 24 PBT instances, suggesting that the large populations used for hyper-parameter tuning by Espeholt et al. may not be necessary.

Note, however, that we have observed larger discrepancies between experiments where small and large population size are used for tuning hyper-parameter, when training the less performing IMPALA agent that used a more limited action set, as presented in the original IMPALA paper.

Figure 6: Larger populations: mean capped human normalised score across the DmLab-30 benchmark as a function of the total number of frames seen by the agents across all levels. The solid lines plot the performance of IMPALA (blue) and PopArt-IMPALA (orange) when tuning hyperparameters with a large PBT population of 24 instances. Dashed lines correspond to the final performance of these same agents, after 10B frames, in the previous experiments where hyper-parameters were tuned with a population of 8.

Pixel Control

Pixel control [Jaderberg et al.2016] is an unsupervised auxiliary task introduced to help learning good state representations. We report here also the performance of combining Pixel Control with IMPALA without also using PopArt. As shown in Figure 7, pixel control increases the performance of both the PopArt-IMPALA agent as well as that of the IMPALA baseline. PopArt still guarantees a noticeable boost in performance, with the median human normalized score of Pixel-PopArt-IMPALA (red line) exceeding the score of Pixel-IMPALA (green line) by approximately 10 points.

We implemented the pixel control task as described in the original paper, only adapting the scheme to the rectangular observations used in DmLab-30. We split the observations into a grid of cells. For each location in the grid we define a distinct pseudo-reward , equal to the absolute value of the difference between pixel intensities in consecutive frames, averaged across the 16 pixels of cell . For each cell, we train action values with multi-step Q-learning, accumulating rewards until the end of a rollout and then bootstrapping. We use a discount . Learning is fully off-policy on experience generated by the actors, that follow the main policy as usual.

We use a deep deconvolutional network for the action value predictions associated to each pseudo-reward

. First, we feed the LSTM’s output to a fully connected layer, reshape the output tensor as

, and apply a deconvolution with kernels that outputs a tensor. From this, we compute a spatial grid of Q-values using a dueling network architecture: we use a deconvolution with 1 output channel for the state values across the grid and a deconvolution with channels for the advantage estimates of each cell. Output deconvolutions use kernels with stride . The additional head is only evaluated on the learner, actors do not execute it.

Figure 7: Pixel Control: mean capped human normalised score across the DmLab-30 benchmark as a function of the total number of frames (summed across levels). Solid lines plot the performance PopArt-IMPALA (red) and IMPALA (green), after augmenting both with pixel control. Dashed lines mark the point at which Pixel-PopArt-IMPALA matches the final performance of previous agents. Note how, thanks to the improved data efficiency, we train for 2B frames, compared to 10B in previous experiments.

Atari-57 Score breakdown

In this section we use barplots to report the final performance of the agents on each of the levels in the Atari-57 multi-task benchmark. In order to compute these scores we take the final trained agent and evaluate it with a frozen policy on each of the levels for 200 episodes. The same trained policy is evaluated in all the levels, and the policy is not provided information about the task it’s being evaluated on. For Atari, we compare PopArt-IMPALA, with and without reward clipping, to an IMPALA baseline. In all cases the height of the bars in the plot denote human normalised score. For the Atari results we additionally rescale logarithmically the x-axis, because in this domain games may differ in their normalised performance by several orders of magnitude.

Figure 8: Atari-57 breakdown: human normalised score for IMPALA and PopArt-IMPALA, as measured in a separate evaluation phase at the end of training, broken down for the 57 games. For PopArt-IMPALA we report the scores both with and without reward clipping

DmLab-30 Score breakdown

In this section we use barplots to report the final performance of the agents on each of the levels in the DmLab-30 multi-task benchmark. In order to compute these scores we take the final trained agent and evaluate it with a frozen policy on each of the levels for 500 episodes. We perform the evaluation over a higher number of episodes (compared to Atari) because the variance of the mean episode return is typically higher in DeepMind Lab. As before, the same trained policy is evaluated on all levels, and the policy is not provided information about the task it’s being evaluated on. Also in DmLab-30 we perform a three-way comparison. We compare PopArt-IMPALA to our improved IMPALA baseline, and, for completeness, to the original paper’s IMPALA.

Figure 9: DmLab-30 breakdown: human normalised score for the original paper’s IMPALA, our improved IMPALA baseline, and PopArt-IMPALA, as measured at the end of training, broken down for the 30 tasks; they all used 8 instances for population based training.

DeepMind Lab action discretisation

DeepMind Lab’s native action space is a 7-dimensional continuous space, whose dimensions correspond to rotating horizontally/vertically, strafing left/right, moving forward/backward, tagging, crouching, and jumping.

Despite the native action space being continuous, previous work on this platform has however typically relied on a coarse discretisation of the action space. We therefore follow the same approach also in our experiments.

Below we list the discretisations used by the agents considered in our experiments. This includes the discretisation used by IMPALA, as well as the one we introduce in this paper in order to unlock some levels in DmLab-30 which just can’t be solved under the original IMPALA discretisation.

Native DmLab Action

Forward (FW)
[  0, 0,  0,  1, 0, 0, 0]
Backward (BW) [  0, 0,  0, -1, 0, 0, 0]
Strafe Left [  0, 0, -1,  0, 0, 0, 0]
Strafe Right [  0, 0,  1,  0, 0, 0, 0]
Look Left (LL) [-20, 0,  0,  0, 0, 0, 0]
Look Right (LR) [ 20, 0,  0,  0, 0, 0, 0]
FW + LL [-20, 0,  0,  1, 0, 0, 0]
FW + LR [ 20, 0,  0,  1, 0, 0, 0]
Fire [  0, 0,  0,  0, 1, 0, 0]

Table 1: Action discretisation used by IMPALA: we report below the discretisation of DeepMind Lab’s action space, as used by the original IMPALA agent in Espeholt et al.
Action Native DmLab Action
FW [  0, 0,  0,  1, 0, 0, 0]
BW [  0, 0,  0, -1, 0, 0, 0]
Strafe Left [  0, 0, -1,  0, 0, 0, 0]
Strafe Right [  0, 0,  1,  0, 0, 0, 0]
Small LL [-10, 0,  0,  0, 0, 0, 0]
Small LR [ 10, 0,  0,  0, 0, 0, 0]
Large LL [-60, 0,  0,  0, 0, 0, 0]
Large LR [ 60, 0,  0,  0, 0, 0, 0]
Look Down [ 0, 10,  0,  0, 0, 0, 0]
Look Up [ 0,-10,  0,  0, 0, 0, 0]
FW + Small LL [-10, 0,  0,  1, 0, 0, 0]
FW + Small LR [ 10, 0,  0,  1, 0, 0, 0]
FW + Large LL [-60, 0,  0,  1, 0, 0, 0]
FW + Large LR [ 60, 0,  0,  1, 0, 0, 0]
Fire [  0, 0,  0,  0, 1, 0, 0]
Table 2: Action discretisation of DeepMind Lab’s action space, as used by our version of IMPALA and by PopArt-IMPALA.

Fixed Hyperparameters

Hyperparameter value
Statistics learning rate 0.0003
Scale lower bound 0.0001
Scale upper bound 1e6
Table 3: PopArt specific hyperparameters: these are held fixed during training and were only very lightly tuned. The lower bound is used to avoid numerical issues when rewards are extremely sparse.
Hyperparameter value
Image Height 72
Image Width 96
Number of action repeats 4
Reward Rescaling -0.3min(tanh(r),0)+
Table 4: DeepMind Lab preprocessing. As in previous work on DeepMind Lab, we render the observation with a resolution of [72, 96], as well as use 4 action repeats. We also employ the optimistic asymmetric rescaling (OAR) of rewards, that was introduced in Espeholt et al. for exploration.
Hyperparameter value
Image Height 84
Image Width 84
Grey scaling True
Max-pooling 2 consecutive frames True
Frame Stacking 4
End of episode on life loss True
Reward Clipping (if used) [-1, 1]
Number of action repeats 4
Table 5: Atari preprocessing. The standard Atari-preprocessing is used in the Atari experiments. Since the introduction of DQN these setting have become a standard practice when training deep RL agent on Atari. Note however, that we report experiments training agents both with and without reward clipping.
Hyperparameter value
Unroll length 20 (Atari), 100 (DmLab)
Discount 0.99
Baseline loss weight 0.5
Batch size 32
Optimiser RMSProp
RMSProp momentum 0.
Table 6: Other agent hyperparameters: These hyperparameters are the same used by Espeholt et al.

Network Architecture

Hyperparameter value
Convolutional Stack
- Number of sections 3
- Channels per section [16, 32, 32]

- Activation Function

ResNet section
- Conv 1 / 3x3 / 1)
- Max-Pool 1 / 3x3 / 2
- Conv 2 / 3x3 / 1
- Skip Identity
- Conv 2 / 3x3 / 1
- Skip Identity
Language preprocessing
- Word embeddings 20
- Sentence embedding LSTM / 64
Fully connected layer 256
LSTM (DmLab-only) 256
Network Heads
- Value Linear
- Policy Linear+softmax
Table 7: Network hyperparameters. The network architecture is described in details in Espeholt et al., For completeness, we also report in the Table below the complete specification of the network. Convolutional layers are specified according to the pattern (num_layers, kernel_size, stride).

Population Based Training

Hyperparameter value
Population Size (Atari) 24
Population Size (DmLab) 8
Fitness Mean capped
human normalised
score (cap=100)
Table 8: Population Based Training: we use PBT for tuning hyper-parameters, as described in Espeholt et al., with population size and fitness function as defined below.
Hyperparameter distribution
Entropy cost Log-uniform on
[5e-5, 1e-2]
Learning rate Log-uniform on
[5e-6, 5e-3]
RMSProp epsilon Categorical on
[1e-1, 1e-3, 1e-5, 1e-7]
Max Grad Norm Uniform on
[10, 100]
Table 9: hyperparameters tuned with population based training are listed below: note that these are the same used by all baseline agents we compare to, to ensure fair comparisons.