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 optimisesfrequency 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 rewardand 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 policywhich 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 returnthat 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 111www.github.com/deepmind/scalable_agent, 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).
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.
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 suitablynormalised 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
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.
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.
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.
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 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.
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.
We implemented all agents in TensorFlow. For each batch of rollouts processed by the learner, we average thetargets 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.
[Bacon, Harb, and Precup2017]
Bacon, P.; Harb, J.; and Precup, D.
The option-critic architecture.
AAAI Conference on Artificial Intelligence.
- [Beattie et al.2016] Beattie, C.; Leibo, J. Z.; Teplyashin, D.; Ward, T.; Wainwright, M.; Küttler, H.; Lefrancq, A.; Green, S.; Valdés, V.; Sadik, A.; Schrittwieser, J.; Anderson, K.; York, S.; Cant, M.; Cain, A.; Bolton, A.; Gaffney, S.; King, H.; Hassabis, D.; Legg, S.; and Petersen, S. 2016. Deepmind lab. CoRR abs/1612.03801.
- [Bellemare et al.2013] Bellemare, M. G.; Naddaf, Y.; Veness, J.; and Bowling, M. 2013. The arcade learning environment: An evaluation platform for general agents. JAIR.
- [Bellman1957] Bellman, R. 1957. A markovian decision process. Journal of Mathematics and Mechanics.
- [Brunskill and Li2013] Brunskill, E., and Li, L. 2013. Sample complexity of multi-task reinforcement learning. CoRR abs/1309.6821.
- [Caruana1998] Caruana, R. 1998. Multitask learning. In Learning to learn.
[Collobert and Weston2008]
Collobert, R., and Weston, J.
A unified architecture for natural language processing: Deep neural networks with multitask learning.In ICML.
- [Degris and Modayil2012] Degris, T., and Modayil, J. 2012. Scaling-up knowledge for a cognizant robot. In AAAI Spring Symposium: Designing Intelligent Robots.
- [Duan et al.2016] Duan, Y.; Chen, X.; Houthooft, R.; Schulman, J.; and Abbeel, P. 2016. Benchmarking deep reinforcement learning for continuous control. In ICML.
- [Espeholt et al.2018] Espeholt, L.; Soyer, H.; Munos, R.; Simonyan, K.; Mnih, V.; Ward, T.; Doron, Y.; Firoiu, V.; Harley, T.; Dunning, I.; Legg, S.; and Kavukcuoglu, K. 2018. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. In ICML.
- [French1999] French, R. M. 1999. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences.
- [Gruslys et al.2018] Gruslys, A.; Azar, M. G.; Bellemare, M. G.; and Munos, R. 2018. The reactor: A sample-efficient actor-critic architecture. ICLR.
- [Hashimoto et al.2016] Hashimoto, K.; Xiong, C.; Tsuruoka, Y.; and Socher, R. 2016. A joint many-task model: Growing a neural network for multiple NLP tasks. CoRR abs/1611.01587.
- [He et al.2015] He, K.; Zhang, X.; Ren, S.; and Sun, J. 2015. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385.
- [Hessel et al.2018] Hessel, M.; Modayil, J.; van Hasselt, H.; Schaul, T.; Ostrovski, G.; Dabney, W.; Horgan, D.; Piot, B.; Azar, M. G.; and Silver, D. 2018. Rainbow: Combining improvements in deep reinforcement learning. AAAI Conference on Artificial Intelligence.
- [Hochreiter and Schmidhuber1997] Hochreiter, S., and Schmidhuber, J. 1997. Long short-term memory. Neural computation.
- [Jaderberg et al.2016] Jaderberg, M.; Mnih, V.; Czarnecki, W. M.; Schaul, T.; Leibo, J. Z.; Silver, D.; and Kavukcuoglu, K. 2016. Reinforcement learning with unsupervised auxiliary tasks. CoRR abs/1611.05397.
- [Jaderberg et al.2017] Jaderberg, M.; Dalibard, V.; Osindero, S.; Czarnecki, W. M.; Donahue, J.; Razavi, A.; Vinyals, O.; Green, T.; Dunning, I.; Simonyan, K.; Fernando, C.; and Kavukcuoglu, K. 2017. Population based training of neural networks. CoRR abs/1711.09846.
[Johnson et al.2017]
Johnson, M.; Schuster, M.; Le, Q. V.; Krikun, M.; Wu, Y.; Chen, Z.; Thorat, N.;
Viégas, F. B.; Wattenberg, M.; Corrado, G.; Hughes, M.; and Dean, J.
Google’s multilingual neural machine translation system: Enabling zero-shot translation.Transactions of the Association for Computational Linguistics 5.
- [Kirkpatrick et al.2017] Kirkpatrick, J.; Pascanu, R.; Rabinowitz, N.; Veness, J.; Desjardins, G.; Rusu, A. A.; Milan, K.; Quan, J.; Ramalho, T.; Grabska-Barwinska, A.; Hassabis, D.; Clopath, C.; Kumaran, D.; and Hadsell, R. 2017. Overcoming catastrophic forgetting in neural networks. PNAS.
- [Lample and Chaplot2016] Lample, G., and Chaplot, D. S. 2016. Playing FPS games with deep reinforcement learning. CoRR abs/1609.05521.
- [Legg and Hutter2007] Legg, S., and Hutter, M. 2007. Universal intelligence: A definition of machine intelligence. Minds Mach.
- [Levine et al.2016] Levine, S.; Pastor, P.; Krizhevsky, A.; and Quillen, D. 2016. Learning hand-eye coordination for robotic grasping with large-scale data collection. In ISER.
- [Lillicrap et al.2016] Lillicrap, T.; Hunt, J.; Pritzel, A.; Heess, N.; Erez, T.; Tassa, Y.; Silver, D.; and Wierstra, D. 2016. Continuous control with deep reinforcement learning. In ICLR.
- [Lu et al.2016] Lu, Y.; Kumar, A.; Zhai, S.; Cheng, Y.; Javidi, T.; and Feris, R. S. 2016. Fully-adaptive feature sharing in multi-task networks with applications in person attribute classification. CoRR abs/1611.05377.
- [Mahmood2017] Mahmood, A. 2017. Incremental off-policy reinforcement learning algorithms. Ph.D. UAlberta.
- [Mankowitz et al.2018] Mankowitz, D. J.; Zídek, A.; Barreto, A.; Horgan, D.; Hessel, M.; Quan, J.; Oh, J.; van Hasselt, H.; Silver, D.; and Schaul, T. 2018. Unicorn: Continual learning with a universal, off-policy agent. CoRR abs/1802.08294.
- [Mcclelland, Mcnaughton, and O’Reilly1995] Mcclelland, J. L.; Mcnaughton, B. L.; and O’Reilly, R. C. 1995. Why there are complementary learning systems in the hippocampus and neocortex: Insights from the successes and failures of connectionist models of learning and memory. Psychological Review.
- [Mirowski et al.2016] Mirowski, P.; Pascanu, R.; Viola, F.; Soyer, H.; Ballard, A. J.; Banino, A.; Denil, M.; Goroshin, R.; Sifre, L.; Kavukcuoglu, K.; Kumaran, D.; and Hadsell, R. 2016. Learning to navigate in complex environments. CoRR abs/1611.03673.
- [Misra et al.2016] Misra, I.; Shrivastava, A.; Gupta, A.; and Hebert, M. 2016. Cross-stitch networks for multi-task learning. CoRR abs/1604.03539.
- [Mnih et al.2015] Mnih, V.; Kavukcuoglu, K.; Silver, D.; Rusu, A. A.; Veness, J.; Bellemare, M. G.; Graves, A.; Riedmiller, M.; Fidjeland, A. K.; Ostrovski, G.; Petersen, S.; Beattie, C.; Sadik, A.; Antonoglou, I.; King, H.; Kumaran, D.; Wierstra, D.; Legg, S.; and Hassabis, D. 2015. Human-level control through deep reinforcement learning. Nature.
- [Mnih et al.2016] Mnih, V.; Badia, A. P.; Mirza, M.; Graves, A.; Lillicrap, T.; Harley, T.; Silver, D.; and Kavukcuoglu, K. 2016. Asynchronous methods for deep reinforcement learning. In ICML.
- [Nair et al.2015] Nair, A.; Srinivasan, P.; Blackwell, S.; Alcicek, C.; Fearon, R.; De Maria, A.; Panneershelvam, V.; Suleyman, M.; Beattie, C.; Petersen, S.; Legg, S.; Mnih, V.; Kavukcuoglu, K.; and Silver, D. 2015. Massively parallel methods for deep reinforcement learning. arXiv preprint arXiv:1507.04296.
- [Osband et al.2016] Osband, I.; Blundell, C.; Pritzel, A.; and Van Roy, B. 2016. Deep exploration via bootstrapped DQN. In NIPS.
- [Parisotto, Ba, and Salakhutdinov2015] Parisotto, E.; Ba, L. J.; and Salakhutdinov, R. 2015. Actor-mimic: Deep multitask and transfer reinforcement learning. CoRR abs/1511.06342.
- [Precup, Sutton, and Singh2000] Precup, D.; Sutton, R. S.; and Singh, S. P. 2000. Eligibility traces for off-policy policy evaluation. In ICML.
- [Ring1994] Ring, M. 1994. Continual learning in reinforcement environments.
- [Romera-Paredes et al.2013] Romera-Paredes, B.; Aung, H.; Bianchi-Berthouze, N.; and Pontil, M. 2013. Multilinear multitask learning. In ICML.
- [Rusu et al.2015] Rusu, A. A.; Colmenarejo, S. G.; Gülçehre, Ç.; Desjardins, G.; Kirkpatrick, J.; Pascanu, R.; Mnih, V.; Kavukcuoglu, K.; and Hadsell, R. 2015. Policy distillation. CoRR abs/1511.06295.
- [Rusu et al.2016] Rusu, A. A.; Rabinowitz, N. C.; Desjardins, G.; Soyer, H.; Kirkpatrick, J.; Kavukcuoglu, K.; Pascanu, R.; and Hadsell, R. 2016. Progressive neural networks. CoRR abs/1606.04671.
- [Schmidhuber1990] Schmidhuber, J. 1990. An on-line algorithm for dynamic reinforcement learning and planning in reactive environments. In IJCNN.
- [Schmitt et al.2018] Schmitt, S.; Hudson, J. J.; Zídek, A.; Osindero, S.; Doersch, C.; Czarnecki, W. M.; Leibo, J. Z.; Küttler, H.; Zisserman, A.; Simonyan, K.; and Eslami, S. M. A. 2018. Kickstarting deep reinforcement learning. CoRR abs/1803.03835.
- [Schulman et al.2015] Schulman, J.; Levine, S.; Moritz, P.; Jordan, M. I.; and Abbeel, P. 2015. Trust region policy optimization. CoRR abs/1502.05477.
- [Schulman et al.2017] Schulman, J.; Wolski, F.; Dhariwal, P.; Radford, A.; and Klimov, O. 2017. Proximal policy optimization algorithms. CoRR abs/1707.06347.
- [Sharma and Ravindran2017] Sharma, S., and Ravindran, B. 2017. Online multi-task learning using active sampling. CoRR abs/1702.06053.
- [Shelhamer et al.2016] Shelhamer, E.; Mahmoudieh, P.; Argus, M.; and Darrell, T. 2016. Loss is its own reward: Self-supervision for reinforcement learning. CoRR abs/1612.07307.
- [Silver et al.2016] Silver, D.; Huang, A.; Maddison, C. J.; Guez, A.; Sifre, L.; van den Driessche, G.; Schrittwieser, J.; Antonoglou, I.; Panneershelvam, V.; Lanctot, M.; Dieleman, S.; Grewe, D.; Nham, J.; Kalchbrenner, N.; Sutskever, I.; Lillicrap, T.; Leach, M.; Kavukcuoglu, K.; Graepel, T.; and Hassabis, D. 2016. Mastering the game of Go with deep neural networks and tree search. Nature.
- [Silver et al.2017] Silver, D.; Hubert, T.; Schrittwieser, J.; Antonoglou, I.; Lai, M.; Guez, A.; Lanctot, M.; Sifre, L.; Kumaran, D.; Graepel, T.; Lillicrap, T. P.; Simonyan, K.; and Hassabis, D. 2017. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. CoRR abs/1712.01815.
- [Sutton and Barto2018] Sutton, R. S., and Barto, A. G. 2018. Reinforcement Learning: An Introduction. MIT press.
- [Sutton et al.2011] Sutton, R. S.; Modayil, J.; Delp, M.; Degris, T.; Pilarski, P. M.; White, A.; and Precup, D. 2011. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In AAMAS.
- [Sutton et al.2014] Sutton, R. S.; Mahmood, A. R.; Precup, D.; and van Hasselt, H. 2014. A new q() with interim forward view and Monte Carlo equivalence. In ICML.
- [Teh et al.2017] Teh, Y. W.; Bapst, V.; Czarnecki, W. M.; Quan, J.; Kirkpatrick, J.; Hadsell, R.; Heess, N.; and Pascanu, R. 2017. Distral: Robust multitask reinforcement learning. CoRR abs/1707.04175.
- [Thrun1996] Thrun, S. 1996. Is learning the n-th thing any easier than learning the first? In NIPS.
- [Thrun2012] Thrun, S. 2012. Explanation-based neural network learning: A lifelong learning approach. Springer.
- [Todorov2009] Todorov, E. 2009. Compositionality of optimal control laws. In NIPS.
- [van Hasselt et al.2016] van Hasselt, H.; Guez, A.; Hessel, M.; Mnih, V.; and Silver, D. 2016. Learning values across many orders of magnitude. In NIPS.
- [van Hasselt, Guez, and Silver2016] van Hasselt, H.; Guez, A.; and Silver, D. 2016. Deep reinforcement learning with double Q-learning. In AAAI Conference on Artificial Intelligence.
- [Watkins1989] Watkins, C. J. C. H. 1989. Learning from Delayed Rewards. Ph.D. Dissertation, King’s College, Cambridge, England.
- [Williams1992] Williams, R. 1992. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Mach. Learning.
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.
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.
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.
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.
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.
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|
|[ 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]|
|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]|
|Statistics learning rate||0.0003|
|Scale lower bound||0.0001|
|Scale upper bound||1e6|
|Number of action repeats||4|
|Max-pooling 2 consecutive frames||True|
|End of episode on life loss||True|
|Reward Clipping (if used)||[-1, 1]|
|Number of action repeats||4|
|Unroll length||20 (Atari), 100 (DmLab)|
|Baseline loss weight||0.5|
|- Number of sections||3|
|- Channels per section||[16, 32, 32]|
|- Conv||1 / 3x3 / 1)|
|- Max-Pool||1 / 3x3 / 2|
|- Conv||2 / 3x3 / 1|
|- Conv||2 / 3x3 / 1|
|- Word embeddings||20|
|- Sentence embedding||LSTM / 64|
|Fully connected layer||256|
Population Based Training
|Population Size (Atari)||24|
|Population Size (DmLab)||8|
|Entropy cost||Log-uniform on|
|Learning rate||Log-uniform on|
|RMSProp epsilon||Categorical on|
|[1e-1, 1e-3, 1e-5, 1e-7]|
|Max Grad Norm||Uniform on|