Distral: Robust Multitask Reinforcement Learning
Abstract
Most deep reinforcement learning algorithms are data inefficient in complex and rich environments, limiting their applicability to many scenarios. One direction for improving data efficiency is multitask learning with shared neural network parameters, where efficiency may be improved through transfer across related tasks. In practice, however, this is not usually observed, because gradients from different tasks can interfere negatively, making learning unstable and sometimes even less data efficient. Another issue is the different reward schemes between tasks, which can easily lead to one task dominating the learning of a shared model. We propose a new approach for joint training of multiple tasks, which we refer to as Distral (Distill & transfer learning). Instead of sharing parameters between the different workers, we propose to share a “distilled” policy that captures common behaviour across tasks. Each worker is trained to solve its own task while constrained to stay close to the shared policy, while the shared policy is trained by distillation to be the centroid of all task policies. Both aspects of the learning process are derived by optimizing a joint objective function. We show that our approach supports efficient transfer on complex 3D environments, outperforming several related methods. Moreover, the proposed learning process is more robust and more stable—attributes that are critical in deep reinforcement learning.
Distral: Robust Multitask Reinforcement Learning
Yee Whye Teh, Victor Bapst, Wojciech Marian Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, Razvan Pascanu DeepMind, London, UK {ywteh,vbapst,lejlot,johnquan,kirkpatrick,raia,heess,razp}@google.com
noticebox[b]\end@float
1 Introduction
Deep Reinforcement Learning is an emerging subfield of Reinforcement Learning (RL) that relies on deep neural networks as function approximators that can scale RL algorithms to complex and rich environments. One key work in this direction was the introduction of DQN Mnih2015Human () which is able to play many games in the ATARI suite of games bellemare13arcade () at above human performance. However the agent requires a fairly large amount of time and data to learn effective policies and the learning process itself can be quite unstable, even with innovations introduced to improve wall clock time, data efficiency, and robustness by changing the learning algorithm Schaul2015Prioritzed (); Hasselt2015Deep () or by improving the optimizer MniBadMir2016a (); Schulman2015Trust (). A different approach was introduced by Jaderber2016Reinforcement (); Mirowski2016Learning (); Lample2016Playing (), whereby data efficiency is improved by training additional auxiliary tasks jointly with the RL task.
With the success of deep RL has come interest in increasingly complex tasks and a shift in focus towards scenarios in which a single agent must solve multiple related problems, either simultaneously or sequentially. Due to the large computational cost, making progress in this direction requires robust algorithms which do not rely on taskspecific algorithmic design or extensive hyperparameter tuning. Intuitively, solutions to related tasks should facilitate learning since the tasks share common structure, and thus one would expect that individual tasks should require less data or achieve a higher asymptotic performance. Indeed this intuition has long been pursued in the multitask and transferlearning literature Bengio12deeplearning (); AAAIMag11Taylor (); yosinskinips2014 (); Caruana:1997 ().
Somewhat counterintuitively, however, the above is often not the result encountered in practice, particularly in the RL domain RusColGul2015a (); ParBaSal2016a (). Instead, the multitask and transfer learning scenarios are frequently found to pose additional challenges to existing methods. Instead of making learning easier it is often observed that training on multiple tasks can negatively affect performances on the individual tasks, and additional techniques have to be developed to counteract this RusColGul2015a (); ParBaSal2016a (). It is likely that gradients from other tasks behave as noise, interfering with learning, or, in another extreme, one of the tasks might dominate the others.
In this paper we develop an approach for multitask and transfer RL that allows effective sharing of behavioral structure across tasks, giving rise to several algorithmic instantiations. In addition to some instructive illustrations on a grid world domain, we provide a detailed analysis of the resulting algorithms via comparisons to A3C MniBadMir2016a () baselines on a variety of tasks in a firstperson, visuallyrich, 3D environment (DeepMind Lab beattie2016deepmind ()). We find that the Distral algorithms learn faster and achieve better asymptotic performance, are significantly more robust to hyperparameter settings, and learn more stably than multitask A3C baselines.
2 Distral: Distill and Transfer Learning
We propose a framework for simultaneous reinforcement learning of multiple tasks which we call Distral. Figure 1 provides a high level illustration involving four tasks. The method is founded on the notion of a shared policy (shown in the centre) which distills (in the sense of Bucila and Hinton et al. BucCarNic06 (); HinVinDea2014 ()) common behaviours or representations from taskspecific policies RusColGul2015a (); ParBaSal2016a (). Crucially, the distilled policy is then used to guide taskspecific policies via regularization using a KullbackLeibler (KL) divergence. The effect is akin to a shaping reward which can, for instance, overcome random walk exploration bottlenecks. In this way, knowledge gained in one task is distilled into the shared policy, then transferred to other tasks.
2.1 Mathematical framework
In this section we describe the mathematical framework underlying Distral. A multitask RL setting is considered where there are tasks, where for simplicity we assume an infinite horizon with discount factor .^{1}^{1}1The method can be easily generalized to other scenarios like undiscounted finite horizon. We will assume that the action and state spaces are the same across tasks; we use to denote actions, to denote states. The transition dynamics and reward functions are different for each task . Let be taskspecific stochastic policies. The dynamics and policies give rise to joint distributions over state and action trajectories starting from some initial state, which we will also denote by by an abuse of notation.
Our mechanism for linking the policy learning across tasks is via optimising an objective which consists of expected returns and policy regularizations. We designate to be the distilled policy which we believe will capture agent behaviour that is common across the tasks. We regularize each task policy towards the distilled policy using discounted KL divergences . In addition, we also use a discounted entropy regularization to further encourage exploration. The resulting objective to be maximized is:
(1) 
where are scalar factors which determine the strengths of the KL and entropy regularizations, and and . The term can be thought of as a reward shaping term which encourages actions which have high probability under the distilled policy, while the entropy term encourages exploration. In the above we used the same regularization costs , for all tasks. It is easy to generalize to using taskspecific costs; this can be important if tasks differ substantially in their reward scales and amounts of exploration needed, although it does introduce additional hyperparameters that are expensive to optimize.
2.2 Soft QLearning and Distillation
A range of optimization techniques in the literature can be applied to maximize the above objective, which we will expand on below. To build up intuition for how the method operates, we will start in the simple case of a tabular representation and an alternating maximization procedure which optimizes over given and over given . With fixed, (1) decomposes into separate maximization problems for each task, and is an entropy regularized expected return with redefined (regularized) reward . It can be optimized using soft Qlearning aka G learning, which are based on deriving the following “softened” Bellman updates for the state and action values (see Rawlik2012On (); FoxPakTis2017a (); SchAbbChe2017a (); NacNorXu2017a () for derivations):
(2)  
(3) 
The Bellman updates are softened in the sense that the usual max operator over actions for the state values is replaced by a softmax at inverse temperature , which hardens into a max operator as . The optimal policy is then a Boltzmann policy at inverse temperature :
(4) 
where is a softened advantage function. Note that the softened state values act as the log normalizers in the above. The distilled policy can be interpreted as a policy prior, a perspective wellknown in the literature on RL as probabilistic inference Toussaint2006Probabilistic (); kappen2012optimal (); Rawlik2012On (); FoxPakTis2017a (). However, unlike in past works, it is raised to a power of . This softens the effect of the prior on , and is the result of the additional entropy regularization beyond the KL divergence.
Also unlike past works, we will learn instead of handpicking it (typically as a uniform distribution over actions). In particular, notice that the only terms in (1) depending on are:
(5) 
which is simply a log likelihood for fitting a model to a mixture of discounted stateaction distributions, one for each task under policy . A maximum likelihood (ML) estimator can be derived from stateaction visitation frequencies under rollouts in each task, with the optimal ML solution given by the mixture of stateconditional action distributions. Alternatively, in the nontabular case, stochastic gradient ascent can be employed, which leads precisely to an update which distills the task policies into BucCarNic06 (); HinVinDea2014 (); RusColGul2015a (); ParBaSal2016a (). Note however that in our case the distillation step is derived naturally from a KL regularized objective on the policies. Another difference from RusColGul2015a (); ParBaSal2016a () and from prior works on the use of distillation in deep learning BucCarNic06 (); HinVinDea2014 () is that the distilled policy is “fed back in” to improve the task policies when they are next optimized, and serves as a conduit in which common and transferable knowledge is shared across the task policies.
It is worthwhile here to take pause and ponder the effect of the extra entropy regularization. First suppose that there is no extra entropy regularization, , and consider the simple scenario of only task. Then (5) is maximized when the distilled policy and the task policy are equal, and the KL regularization term is 0. Thus the objective reduces to an unregularized expected return, and so the task policy converges to a greedy policy which locally maximizes expected returns. Another way to view this line of reasoning is that the alternating maximization scheme is equivalent to trustregion methods like natural gradient or TRPO PascanuNatural14 (); Schulman2015Trust () which use a KL ball centred at the previous policy, and which are understood to converge to greedy policies.
If , there is an additional entropy term in (1). So even with and , the objective (1) will no longer be maximized by greedy policies. Instead (1) reduces to an entropy regularized expected returns with entropy regularization factor , so that the optimal policy is of the Boltzmann form with inverse temperature Rawlik2012On (); FoxPakTis2017a (); SchAbbChe2017a (); NacNorXu2017a (). In conclusion, by including the extra entropy term, we can guarantee that the task policy will not turn greedy, and we can control the amount of exploration by adjusting appropriately.
This additional control over the amount of exploration is essential when there are more than one task. To see this, imagine a scenario where one of the tasks is easier and is solved first, while other tasks are harder with much sparser rewards. Without the entropy term, and before rewards in other tasks are encountered, both the distilled policy and all the task policies can converge to the one that solves the easy task. Further, because this policy is greedy, it can insufficiently explore the other tasks to even encounter rewards, leading to suboptimal behaviour. For singletask RL, the use of entropy regularization was recently popularized by Mnih et al. MniBadMir2016a () to counter premature convergence to greedy policies, which can be particularly severe when doing policy gradient learning. This carries over to our multitask scenario as well, and is the reason for the additional entropy regularization.
2.3 Policy Gradient and a Better Parameterization
The above method alternates between maximization of the distilled policy and the task policies , and is reminiscent of the EM algorithm DemLaiRub1977a () for learning latent variable models, with playing the role of parameters, while plays the role of the posterior distributions for the latent variables. Going beyond the tabular case, when both and are parameterized by, say, deep networks, such an alternating maximization procedure can be slower than simply optimizing (1) with respect to task and distilled policies jointly by stochastic gradient ascent. In this case the gradient update for is simply given by policy gradient with an entropic regularization MniBadMir2016a (); SchAbbChe2017a (), and can be carried out within a framework like advantage actorcritic MniBadMir2016a ().
A simple parameterization of policies would be to use a separate network for each task policy , and another one for the distilled policy . An alternative parameterization, which we argue can result in faster transfer, can be obtained by considering the form of the optimal Boltzmann policy (4). Specifically, consider parameterizing the distilled policy using a network with parameters ,
(6) 
and estimating the soft advantages^{2}^{2}2In practice, we do not actually use these as advantage estimates. Instead we use (8) to parameterize a policy which is optimized by policy gradients. using another network with parameters :
(7) 
We used hat notation to denote parameterized approximators of the corresponding quantities. The policy for task then becomes parameterized as,
(8) 
This can be seen as a twocolumn architecture for the policy, with one column being the distilled policy, and the other being the adjustment required to specialize to task .
Given the parameterization above, we can now derive the policy gradients. The gradient wrt to the task specific parameters is given by the standard policy gradient theorem sutton1999policy (),
(9) 
where is the regularized reward. Note that the partial derivative of the entropy in the integrand has expectation because of the logderivative trick. If a value baseline is estimated, it can be subtracted from the regularized returns in order to reduce gradient variance. The gradient wrt is more interesting:
(10)  
Note that the first term is the same as for the policy gradient of . The second term tries to match the probabilities under the task policy and under the distilled policy . The second term would not be present if we simply parameterized using the same architecture , but do not use a KL regularization for the policy. The presence of the KL regularization gets the distilled policy to learn to be the centroid of all task policies, in the sense that the second term would be zero if , and helps to transfer information quickly across tasks and to new tasks.
The centroid and starshaped structure of DisTraL is reminiscent of ADMM Boyd2011 (), elasticaveraging SGD ZhaChoLec2015 () and hierarchical Bayes gelman2014bayesian (). Though a crucial difference is that while ADMM, EASGD and hierarchical Bayes operate in the space of parameters, in Distral the distilled policy learns to be the centroid in the space of policies. We argue that this is semantically more meaningful, and may contribute to the observed robustness of Distral by stabilizing learning. In our experiments we find indeed that absence of the KL regularization significantly affects the stability of the algorithm.
Our approach is also reminiscent of recent work on option learning fox2016principled (), but with a few important differences. We focus on using deep neural networks as flexible function approximators, and applied our method to rich 3D visual environments, while Fox et al. fox2016principled () considered only the tabular case. We argue for the importance of an additional entropy regularization besides the KL regularization. This lead to an interesting twist in the mathematical framework allowing us to separately control the amounts of transfer and of exploration. On the other hand Fox et al. fox2016principled () focused on the interesting problem of learning multiple options (distilled policies here). Their approach treats the assignment of tasks to options as a clustering problem, which is not easily extended beyond the tabular case.
3 Algorithms
The framework we just described allows for a number of possible algorithmic instantiations, arising as combinations of objectives, algorithms and architectures, which we describe below and summarize in Table 1 and Figure 2. KL divergence vs entropy regularization: With , we get a purely entropyregularized objective which does not couple and transfer across tasks MniBadMir2016a (); SchAbbChe2017a (). With , we get a purely KL regularized objective, which does couple and transfer across tasks, but might prematurely stop exploration if the distilled and task policies become similar and greedy. With we get both terms. Alternating vs joint optimization: We have the option of jointly optimizing both the distilled policy and the task policies, or optimizing one while keeping the other fixed. Alternating optimization leads to algorithms that resemble policy distillation/actormimic ParBaSal2016a (); RusColGul2015a (), but are iterative in nature with the distilled policy feeding back into task policy optimization. Also, soft Qlearning can be applied to each task, instead of policy gradients. While alternating optimization can be slower, evidence from policy distillation/actormimic indicate it might learn more stably, particularly for tasks which differ significantly. Separate vs twocolumn parameterization: Finally, the task policy can be parameterized to use the distilled policy (8) or not. If using the distilled policy, behaviour distilled into the distilled policy is “immediately available” to the task policies so transfer can be faster. However if the process of transfer occurs too quickly, it might prevent effective exploration of individual tasks.
From this spectrum of possibilities we consider four concrete instances which differ in the underlying network architecture and distillation loss, identified in Table 1. In addition, we compare against three A3C baselines. In initial experiments we explored two variants of A3C: the original method MniBadMir2016a () and the variant of Schulman et al. SchAbbChe2017a () which uses entropy regularized returns. We did not find significant differences for the two variants in our setting, and chose to report only the original A3C results for clarity in Section 4. Further algorithmic details are provided in the Appendix.
A3C multitask  A3C  A3C 2col  
KL 1col  KL 2col  
KL+ent 1col  KL+ent 2col 
4 Experiments
We demonstrate the various algorithms derived from our framework, firstly using alternating optimization with soft Qlearning and policy distillation on a set of simple grid world tasks. Then all seven algorithms will be evaluated on three sets of challenging RL tasks in partially observable 3D environments beattie2016deepmind ().
4.1 Two room grid world
To give better intuition for the role of the distilled behaviour policy, we considered a set of tasks in a grid world domain with two rooms connected by a corridor (see Figure 3) fox2016principled (). Each task is distinguished by a different randomly chosen goal location and each MDP state consists of the map location, the previous action and the previous reward. A Distral agent is trained using only the KL regularization and an optimization algorithm which alternates between soft Qlearning and policy distillation. Each soft Qlearning iteration learns using a rollout of length 10.
To determine the benefit of the distilled policy, we compared the Distral agent to one which soft Q learns a separate policy for each task. The learning curves are shown in Figure 3 (left). We see that the Distral agent is able to learn significantly faster than singletask agents. Figure 3 (right) visualizes the distilled policy (probability of next action given position and previous action), demonstrating that the agent has learnt a robust policy which guides the agent to move consistently in the corridor in order to reach the other room. This allows the agent to reach the other room faster and helps exploration, if the agent is shown new test tasks. In Fox et al. fox2016principled () two separate options are learnt, while here we learn a single distilled policy which conditions on more past information.
4.2 Complex Tasks
To assess Distral under more challenging conditions, we use a complex firstperson partially observed 3D environment with a variety of visuallyrich RL tasks beattie2016deepmind (). All agents were implemented with a distributed Python/TensorFlow code base, using 32 workers for each task and learnt using asynchronous RMSProp. The network columns contain convolutional layers and an LSTM and are uniform across experiments and algorithms. We tried three values for the entropy costs and three learning rates . Four runs for each hyperparameter setting were used. All other hyperparameters were fixed to the singletask A3C defaults and, for the KL+ent 1col and KL+ent 2col algorithms, was fixed at .
Mazes In the first experiment, each of tasks is a different maze containing randomly placed rewards and a goal object. Figure 4.A1 shows the learning curves for all seven algorithms. Each curve is produced by averaging over all 4 runs and 8 tasks, and selecting the best settings for and (as measured by the area under the learning curves). The Distral algorithms learn faster and achieve better final performance than all three A3C baselines. The twocolumn algorithms learn faster than the corresponding single column ones. The Distral algorithms without entropy learn faster but achieve lower final scores than those with entropy, which we believe is due to insufficient exploration towards the end of learning.
We found that both multitask A3C and twocolumn A3C can learn well on some runs, but are generally unstable—some runs did not learn well, while others may learn initially then suffer degradation later. We believe this is due to negative interference across tasks, which does not happen for Distral algorithms. The stability of Distral algorithms also increases their robustness to hyperparameter selection. Figure 4.A2 shows the final achieved average returns for all 36 runs for each algorithm, sorted in decreasing order. We see that Distral algorithms have a significantly higher proportion of runs achieving good returns, with KL+ent_2col being the most robust.
DisTraL algorithms, along with multitask A3C, use a distilled or common policy which can be applied on all tasks. Panels B1 and B2 in Figure 4 summarize the performances of the distilled policies. Algorithms that use two columns (KL_2col and KL+ent_2col) obtain the best performance, because policy gradients are also directly propagated through the distilled policy in those cases. Moreover, panel B2 reveals that Distral algorithms exhibit greater stability as compared to traditional multitask A3C. We also observe that KL algorithms have betterperforming distilled policies than KL+ent ones. We believe this is because the additional entropy regularization allows task policies to diverge more substantially from the distilled policy. This suggests that annealing the entropy term or increasing the KL term throughout training could improve the distilled policy performance, if that is of interest.
Navigation We experimented with navigation and memory tasks. In contrast to the previous experiment, these tasks use random maps which are procedurally generated on every episode. The first task features reward objects which are randomly placed in a maze, and the second task requires to return these objects to the agent’s start position. The third task has a single goal object which must be repeatedly found from different start positions, and on the fourth task doors are randomly opened and closed to force novel pathfinding. Hence, these tasks are more involved than the previous navigation tasks. The panels C1 and C2 of Figure 4 summarize the results. We observe again that Distral algorithms yield better final results while having greater stability (Figure 4.C2). The topperforming algorithms are, again, the 2 column Distral algorithms (KL_2col and KL+ent_2col).
Lasertag In the final set of experiments, we use lasertag levels from DeepMind Lab. These tasks require the agent to learn to tag bots controlled by a builtin AI, and differ substantially: fixed versus procedurally generated maps, fixed versus procedural bots, and complexity of agent behaviour (e.g. learning to jump in some tasks). Corresponding to this greater diversity, we observe (see panels D1 and D2 of Figure 4) that the best baseline is the A3C algorithm that is trained independently on each task. Among the Distral algorithms, the single column variants perform better, especially initially, as they are able to learn taskspecific features separately. We observe again the early plateauing phenomenon for algorithms that do not possess an additional entropy term. While not significantly better than the A3C baseline on these tasks, the Distral algorithms clearly outperform the multitask A3C. Considering the 3 different sets of complex 3D experiments, we argue that the Distral algorithms are the most promising solution to the multitask RL problem.
5 Discussion
We have proposed Distral, a general framework for distilling and transferring common behaviours in multitask reinforcement learning. In experiments we showed that the resulting algorithms learn quicker, produce better final performances, and are more stable and robust to hyperparameter settings. We have found that Distral significantly outperforms the standard way of using shared neural network parameters for multitask or transfer reinforcement learning. Two ideas might be worth reemphasizing here. We observe that distillation arises naturally as one half of an optimization procedure when using KL divergences to regularize the output of task models towards a distilled model. The other half corresponds to using the distilled model as a regularizer for training the task models. Another observation is that parameters in deep networks do not typically by themselves have any semantic meaning, so instead of regularizing networks in parameter space, it is worthwhile considering regularizing networks in a more semantically meaningful space, e.g. of policies.
Possible directions of future research include: combining Distral with techniques which use auxiliary losses Jaderber2016Reinforcement (); Mirowski2016Learning (); Lample2016Playing (), exploring use of multiple distilled policies or latent variables in the distilled policy to allow for more diversity of behaviours, exploring settings for continual learning where tasks are encountered sequentially, and exploring ways to adaptively adjust the KL and entropy costs to better control the amounts of transfer and exploration.
References
 [1] Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Küttler, Andrew Lefrancq, Simon Green, Víctor Valdés, Amir Sadik, et al. Deepmind lab. arXiv:1612.03801, 2016.
 [2] M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, june 2013.
 [3] Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. In JMLR: Workshop on Unsupervised and Transfer Learning, 2012.
 [4] Stephen Boyd, Neal Parikh, Eric Chu, Borja Peleato, and Jonathan Eckstein. Distributed optimization and statistical learning via the alternating direction method of multipliers. Found. Trends Mach. Learn., 3(1), January 2011.
 [5] Cristian Bucila, Rich Caruana, and Alexandru NiculescuMizil. Model compression. In Proc. of the Int’l Conference on Knowledge Discovery and Data Mining (KDD), 2006.
 [6] Rich Caruana. Multitask learning. Machine Learning, 28(1):41–75, July 1997.
 [7] Arthur P Dempster, Nan M Laird, and Donald B Rubin. Maximum likelihood from incomplete data via the em algorithm. Journal of the royal statistical society. Series B (methodological), pages 1–38, 1977.
 [8] R. Fox, A. Pakman, and N. Tishby. Taming the noise in reinforcement learning via soft updates. In Uncertainty in Artificial Intelligence (UAI), 2016.
 [9] Roy Fox, Michal Moshkovitz, and Naftali Tishby. Principled option learning in markov decision processes. In European Workshop on Reinforcement Learning (EWRL), 2016.
 [10] Andrew Gelman, John B Carlin, Hal S Stern, and Donald B Rubin. Bayesian data analysis, volume 2. Chapman & Hall/CRC Boca Raton, FL, USA, 2014.
 [11] Geoffrey E. Hinton, Oriol Vinyals, and Jeffrey Dean. Distilling the knowledge in a neural network. NIPS Deep Learning Workshop, 2014.
 [12] Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. Int’l Conference on Learning Representations (ICLR), 2016.
 [13] Hilbert J Kappen, Vicenç Gómez, and Manfred Opper. Optimal control as a graphical model inference problem. Machine learning, 87(2):159–182, 2012.
 [14] Guillaume Lample and Devendra Singh Chaplot. Playing FPS games with deep reinforcement learning. Association for the Advancement of Artificial Intelligence (AAAI), 2017.
 [15] Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J. Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, Dharshan Kumaran, and Raia Hadsell. Learning to navigate in complex environments. Int’l Conference on Learning Representations (ICLR), 2016.
 [16] Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Int’l Conference on Machine Learning (ICML), 2016.
 [17] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Humanlevel control through deep reinforcement learning. Nature, 518(7540):529–533, 02 2015.
 [18] Ofir Nachum, Mohammad Norouzi, Kelvin Xu, and Dale Schuurmans. Bridging the gap between value and policy based reinforcement learning. arXiv:1702.08892, 2017.
 [19] Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actormimic: Deep multitask and transfer reinforcement learning. In Int’l Conference on Learning Representations (ICLR), 2016.
 [20] Razvan Pascanu and Yoshua Bengio. Revisiting natural gradient for deep networks. Int’l Conference on Learning Representations (ICLR), 2014.
 [21] Konrad Rawlik, Marc Toussaint, and Sethu Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. In Robotics: Science and Systems (RSS), 2012.
 [22] Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. In Int’l Conference on Learning Representations (ICLR), 2016.
 [23] Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. CoRR, abs/1511.05952, 2015.
 [24] J. Schulman, P. Abbeel, and X. Chen. Equivalence between policy gradients and soft QLearning. arXiv:1704.06440, 2017.
 [25] John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Int’l Conference on Machine Learning (ICML), 2015.
 [26] Richard S Sutton, David A McAllester, Satinder P Singh, Yishay Mansour, et al. Policy gradient methods for reinforcement learning with function approximation. In Adv. in Neural Information Processing Systems (NIPS), volume 99, pages 1057–1063, 1999.
 [27] Matthew E. Taylor and Peter Stone. An introduction to intertask transfer for reinforcement learning. AI Magazine, 32(1):15–34, 2011.
 [28] Marc Toussaint, Stefan Harmeling, and Amos Storkey. Probabilistic inference for solving (PO)MDPs. Technical Report EDIINFRR0934, University of Edinburgh, School of Informatics, 2006.
 [29] Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Qlearning. Association for the Advancement of Artificial Intelligence (AAAI), 2016.
 [30] Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Adv. in Neural Information Processing Systems (NIPS), 2014.
 [31] Sixin Zhang, Anna Choromanska, and Yann LeCun. Deep learning with elastic averaging SGD. In Adv. in Neural Information Processing Systems (NIPS), 2015.
Appendix A Algorithms
A description of all the algorithms tested:

A3C: A policy is trained separately for each task using A3C.

A3C_multitask: A single policy is trained using A3C by simultaneously training on all tasks.

A3C_2col: A policy is trained for each task using A3C, which is parameterized using a twocolumn architecture with one column shared across tasks (8).

KL_1col: Each policy including the distilled policy is parameterized by one network, and trained to optimize (1) with , i.e. only using the KL regularization.

KL+ent_1col: Same as KL_1col but using both KL and entropy regularization. We set and did not tune for it in our experiments.

KL_2col: Same as KL_1col but using the twocolumn architecture (8) with one shared network column which also produces the distilled policy .

KL+ent_2col: Same as KL+ent_1col but using the twocolumn architecture.
Appendix B Experimental details
b.1 Two room grid world
The agent can stay put or move in each of the four cardinal coordinates. A penalty of is incurred for every time step and a penalty of is incurred if the agent runs into the wall. On reaching the goal state the episode terminates and the agent gets a reward of . We used learning rate of , discount of for soft Qlearning, , and regularized the distilled policy by using a pseudocount of 1 for each action in each state. The reported results are not sensitive to these settings and we did not tune for them.
b.2 Complex 3D tasks
The three sets of tasks are described in Table 2.
We implemented the updates (910) by training a distributed agent a la A3C [16] with 32 workers for each task, coordinated using parameter servers. The agent receives a RGB observation from the environment in the form of a tensor. Each network column has the same architecture as in Mnih et al. [16] and consists of two convolutional layers with ReLU nonlinearities, followed by a fully connected layer with 256 hidden units and ReLU nonlinearity, which then feeds into an LSTM. Policy logits and values are then read out linearly from the LSTM. We used RMSProp as an optimizer, and batches of length 20.
Num tasks  Intertask variability  Map/maze layout  Objectives and Agent Behaviours  

Mazes  8  low  Fixed layout for each task.  Collect a goal object multiple times from different start positions in the maze. 
Navigation  4  medium  Procedurally varied on every episode.  Various objectives requiring memory and exploration skills, including collecting objects and navigating back to start location, and finding a goal object from multiple start positions with doors that randomly open and close. 
Lasertag  8  high  Fixed for some tasks and procedurally varied for others.  Tag bots controlled by the OpenArena AI while collecting objects to increase score. May require jumping and other agent behaviours. 
We used a set of 9 hyperparameters for the entropy costs and initial learning rate. We kept throughout all runs of KL+ent_1col and KL+ent_2col (and, by definition, we have for A3C, A3C_multitask, A3C_2col and for KL_1col and KL_2col.). The learning rate was annealed linearly from its initial value down to over a total of environment steps per task, where for the maze and navigation tasks, and for the lasertag tasks. We used an actionrepeat of 4 (each action output by the network is fed 4 times to the environment), so the number of training steps in each environment is respectively and . In addition to the updates (910), our implementation had small regularization terms over the state value estimates for each task, in the form of losses with a coefficient , to encourage a small amount of transfer of knowledge in value estimates too. We did not tune for this parameter, and believe it is not essential to our results.
Because of the small values of used, we parameterized times the soft advantages using the network outputs instead, so that (78) read as:
(11)  
(12) 
When reporting results for the navigation and lasertag sets of tasks, we normalized the results by the best performance of a standard A3C agent on a task by task basis, to account for different rewards scales across tasks.