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

Introduction

Deep reinforcement learning methods have recently mastered a wide variety of domains through trial and error learning (Mnih et al., 2015; Silver et al., 2017, 2016; Zoph et al., 2017; Lillicrap et al., 2015; Barth-Maron et al., 2018). While the improvements on tasks like the game of Go (Silver et al., 2017) and Atari games (Horgan et al., 2018) have been dramatic, the progress has been primarily in single task performance, where an agent is trained on each task separately. We are interested in developing new methods capable of mastering a diverse set of tasks simultaneously as well as environments suitable for evaluating such methods.

One of the main challenges in training a single agent on many tasks at once is scalability. Since the current state-of-the-art methods like A3C (Mnih et al., 2016) or UNREAL (Jaderberg et al., 2017b) can require as much as a billion frames and multiple days to master a single domain, training them on tens of domains at once is too slow to be practical.

We propose the Importance Weighted Actor-Learner Architecture (IMPALA) shown in Figure 1. IMPALA is capable of scaling to thousands of machines without sacrificing training stability or data efficiency. Unlike the popular A3C-based agents, in which workers communicate gradients with respect to the parameters of the policy to a central parameter server, IMPALA actors communicate trajectories of experience (sequences of states, actions, and rewards) to a centralised learner. Since the learner in IMPALA has access to full trajectories of experience we use a GPU to perform updates on mini-batches of trajectories while aggressively parallelising all time independent operations. This type of decoupled architecture can achieve very high throughput. However, because the policy used to generate a trajectory can lag behind the policy on the learner by several updates at the time of gradient calculation, learning becomes off-policy. Therefore, we introduce the V-trace off-policy actor-critic algorithm to correct for this harmful discrepancy.

With the scalable architecture and V-trace combined, IMPALA achieves exceptionally high data throughput rates of 250,000 frames per second, making it over 30 times faster than single-machine A3C. Crucially, IMPALA is also more data efficient than A3C based agents and more robust to hyperparameter values and network architectures, allowing it to make better use of deeper neural networks. We demonstrate the effectiveness of IMPALA by training a single agent on multi-task problems using DMLab-30, a new challenge set which consists of 30 diverse cognitive tasks in the 3D DeepMind Lab (Beattie et al., 2016) environment and by training a single agent on all games in the Atari-57 set of tasks.

Related Work

The earliest attempts to scale up deep reinforcement learning relied on distributed asynchronous SGD (Dean et al., 2012) with multiple workers. Examples include distributed A3C (Mnih et al., 2016) and Gorila (Nair et al., 2015), a distributed version of Deep Q-Networks (Mnih et al., 2015). Recent alternatives to asynchronous SGD for RL include using evolutionary processes (Salimans et al., 2017), distributed BA3C (Adamski et al., 2018) and Ape-X (Horgan et al., 2018) which has a distributed replay but a synchronous learner.

There have also been multiple efforts that scale up reinforcement learning by utilising GPUs. One of the simplest of such methods is batched A2C (Clemente et al., 2017). At every step, batched A2C produces a batch of actions and applies them to a batch of environments. Therefore, the slowest environment in each batch determines the time it takes to perform the entire batch step (see Figure 2(a) and 2(b)). In other words, high variance in environment speed can severely limit performance. Batched A2C works particularly well on Atari environments, because rendering and game logic are computationally very cheap in comparison to the expensive tensor operations performed by reinforcement learning agents. However, more visually or physically complex environments can be slower to simulate and can have high variance in the time required for each step. Environments may also have variable length (sub)episodes causing a slowdown when initialising an episode.

The most similar architecture to IMPALA is GA3C (Babaeizadeh et al., 2016), which also uses asynchronous data collection to more effectively utilise GPUs. It decouples the acting/forward pass from the gradient calculation/backward pass by using dynamic batching. The actor/learner asynchrony in GA3C leads to instabilities during learning, which (Babaeizadeh et al., 2016) only partially mitigates by adding a small constant to action probabilities during the estimation of the policy gradient. In contrast, IMPALA uses the more principled V-trace algorithm.

Related previous work on off-policy RL include (Precup et al., 2000, 2001; Wawrzynski, 2009; Geist & Scherrer, 2014; O’Donoghue et al., 2017) and (Harutyunyan et al., 2016). The closest work to ours is the Retrace algorithm (Munos et al., 2016) which introduced an off-policy correction for multi-step RL, and has been used in several agent architectures (Wang et al., 2017; Gruslys et al., 2018). Retrace requires learning state-action-value functions $Q$ in order to make the off-policy correction. However, many actor-critic methods such as A3C learn a state-value function $V$ instead of a state-action-value function $Q$. V-trace is based on the state-value function.

IMPALA

IMPALA (Figure 1) uses an actor-critic setup to learn a policy $\pi$ and a baseline function $V^{\pi}$. The process of generating experiences is decoupled from learning the parameters of $\pi$ and $V^{\pi}$. The architecture consists of a set of actors, repeatedly generating trajectories of experience, and one or more learners that use the experiences sent from actors to learn $\pi$ off-policy.

At the beginning of each trajectory, an actor updates its own local policy $\mu$ to the latest learner policy $\pi$ and runs it for $n$ steps in its environment. After $n$ steps, the actor sends the trajectory of states, actions and rewards $x_{1},a_{1},r_{1},\dots,x_{n},a_{n},r_{n}$ together with the corresponding policy distributions $\mu(a_{t}|x_{t})$ and initial LSTM state to the learner through a queue. The learner then continuously updates its policy $\pi$ on batches of trajectories, each collected from many actors. This simple architecture enables the learner(s) to be accelerated using GPUs and actors to be easily distributed across many machines. However, the learner policy $\pi$ is potentially several updates ahead of the actor’s policy $\mu$ at the time of update, therefore there is a policy-lag between the actors and learner(s). V-trace corrects for this lag to achieve extremely high data throughput while maintaining data efficiency. Using an actor-learner architecture, provides fault tolerance like distributed A3C but often has lower communication overhead since the actors send observations rather than parameters/gradients.

With the introduction of very deep model architectures, the speed of a single GPU is often the limiting factor during training. IMPALA can be used with distributed set of learners to train large neural networks efficiently as shown in Figure 1. Parameters are distributed across the learners and actors retrieve the parameters from all the learners in parallel while only sending observations to a single learner. IMPALA use synchronised parameter update which is vital to maintain data efficiency when scaling to many machines (Chen et al., 2016).

GPUs and many-core CPUs benefit greatly from running few large, parallelisable operations instead of many small operations. Since the learner in IMPALA performs updates on entire batches of trajectories, it is able to parallelise more of its computations than an online agent like A3C. As an example, a typical deep RL agent features a convolutional network followed by a Long Short-Term Memory (LSTM) (Hochreiter & Schmidhuber, 1997) and a fully connected output layer after the LSTM. An IMPALA learner applies the convolutional network to all inputs in parallel by folding the time dimension into the batch dimension. Similarly, it also applies the output layer to all time steps in parallel once all LSTM states are computed. This optimisation increases the effective batch size to thousands. LSTM-based agents also obtain significant speedups on the learner by exploiting the network structure dependencies and operation fusion (Appleyard et al., 2016).

Finally, we also make use of several off the shelf optimisations available in TensorFlow (Abadi et al., 2017) such as preparing the next batch of data for the learner while still performing computation, compiling parts of the computational graph with XLA (a TensorFlow Just-In-Time compiler) and optimising the data format to get the maximum performance from the cuDNN framework (Chetlur et al., 2014).

V-trace

Off-policy learning is important in the decoupled distributed actor-learner architecture because of the lag between when actions are generated by the actors and when the learner estimates the gradient. To this end, we introduce a novel off-policy actor-critic algorithm for the learner, called V-trace.

The goal of an off-policy RL algorithm is to use trajectories generated by some policy $\mu$, called the behaviour policy, to learn the value function $V^{\pi}$ of another policy $\pi$ (possibly different from $\mu$), called the target policy.

Consider a trajectory $\left(x_{t},a_{t},r_{t}\right)_{t=s}^{t=s+n}$ generated by the actor following some policy $\mu$. We define the $n$-steps V-trace target for $V(x_{s})$, our value approximation at state $x_{s}$, as:

where \delta_{t}V\stackrel{{\scriptstyle\rm def}}{{=}}\rho_{t}\big{(}r_{t}+\gamma V(x_{t+1})-V(x_{t})\big{)} is a temporal difference for $V$, and \rho_{t}\stackrel{{\scriptstyle\rm def}}{{=}}\min\big{(}\bar{\rho},\frac{\pi(a_{t}|x_{t})}{\mu(a_{t}|x_{t})}\big{)} and c_{i}\stackrel{{\scriptstyle\rm def}}{{=}}\min\big{(}\bar{c},\frac{\pi(a_{i}|x_{i})}{\mu(a_{i}|x_{i})}\big{)} are truncated importance sampling (IS) weights (we make use of the notation $\prod_{i=s}^{t-1}c_{i}=1$ for $s=t$). In addition we assume that the truncation levels are such that $\bar{\rho}\geq\bar{c}$.

Notice that in the on-policy case (when $\pi=\mu$), and assuming that $\bar{c}\geq 1$, then all $c_{i}=1$ and $\rho_{t}=1$, thus (1) rewrites

which is the on-policy $n$-steps Bellman target. Thus in the on-policy case, V-trace reduces to the on-policy $n$-steps Bellman update. This property (which Retrace (Munos et al., 2016) does not have) allows one to use the same algorithm for off- and on-policy data.

Notice that the (truncated) IS weights $c_{i}$ and $\rho_{t}$ play different roles. The weight $\rho_{t}$ appears in the definition of the temporal difference $\delta_{t}V$ and defines the fixed point of this update rule. In a tabular case, where functions can be perfectly represented, the fixed point of this update (i.e., when $V(x_{s})=v_{s}$ for all states), characterised by $\delta_{t}V$ being equal to zero in expectation (under $\mu$), is the value function $V^{\pi_{\bar{\rho}}}$ of some policy $\pi_{\bar{\rho}}$, defined by

(see the analysis in Appendix A ). So when $\bar{\rho}$ is infinite (i.e. no truncation of $\rho_{t}$), then this is the value function $V^{\pi}$ of the target policy. However if we choose a truncation level $\bar{\rho}<\infty$, our fixed point is the value function $V^{\pi_{\bar{\rho}}}$ of a policy $\pi_{\bar{\rho}}$ which is somewhere between $\mu$ and $\pi$. At the limit when $\bar{\rho}$ is close to zero, we obtain the value function of the behaviour policy $V^{\mu}$. In Appendix A we prove the contraction of a related V-trace operator and the convergence of the corresponding online V-trace algorithm.

The weights $c_{i}$ are similar to the “trace cutting” coefficients in Retrace. Their product $c_{s}\dots c_{t-1}$ measures how much a temporal difference $\delta_{t}V$ observed at time $t$ impacts the update of the value function at a previous time $s$. The more dissimilar $\pi$ and $\mu$ are (the more off-policy we are), the larger the variance of this product. We use the truncation level $\bar{c}$ as a variance reduction technique. However notice that this truncation does not impact the solution to which we converge (which is characterised by $\bar{\rho}$ only).

Thus we see that the truncation levels $\bar{c}$ and $\bar{\rho}$ represent different features of the algorithm: $\bar{\rho}$ impacts the nature of the value function we converge to, whereas $\bar{c}$ impacts the speed at which we converge to this function.

V-trace targets can be computed recursively:

Like in Retrace($\lambda$), we can also consider an additional discounting parameter $\lambda\in$ in the definition of V-trace by setting c_{i}=\lambda\min\big{(}\bar{c},\frac{\pi(a_{i}|x_{i})}{\mu(a_{i}|x_{i})}\big{)}. In the on-policy case, when $n=\infty$, V-trace then reduces to TD($\lambda$).

2 Actor-Critic algorithm

In the on-policy case, the gradient of the value function $V^{\mu}(x_{0})$ with respect to some parameter of the policy $\mu$ is

Now in the off-policy setting that we consider, we can use an IS weight between the policy being evaluated $\pi_{\bar{\rho}}$ and the behaviour policy $\mu$, to update our policy parameter in the direction of

In order to reduce the variance of the policy gradient estimate (4), we usually subtract from $q_{s}$ a state-dependent baseline, such as the current value approximation $V(x_{s})$.

Finally notice that (4) estimates the policy gradient for $\pi_{\bar{\rho}}$ which is the policy evaluated by the V-trace algorithm when using a truncation level $\bar{\rho}$. However assuming the bias $V^{\pi_{\bar{\rho}}}-V^{\pi}$ is small (e.g. if $\bar{\rho}$ is large enough) then we can expect $q_{s}$ to provide us with a good estimate of $Q^{\pi}(x_{s},a_{s})$. Taking into account these remarks, we derive the following canonical V-trace actor-critic algorithm.

V-trace actor-critic algorithm

Consider a parametric representation $V_{\theta}$ of the value function and the current policy $\pi_{\omega}$. Trajectories have been generated by actors following some behaviour policy $\mu$. The V-trace targets $v_{s}$ are defined by (1). At training time $s$, the value parameters $\theta$ are updated by gradient descent on the $l2$ loss to the target $v_{s}$, i.e., in the direction of

and the policy parameters $\omega$ in the direction of the policy gradient:

In order to prevent premature convergence we may add an entropy bonus, like in A3C, along the direction

The overall update is obtained by summing these three gradients rescaled by appropriate coefficients, which are hyperparameters of the algorithm.

Experiments

We investigate the performance of IMPALA under multiple settings. For data efficiency, computational performance and effectiveness of the off-policy correction we look at the learning behaviour of IMPALA agents trained on individual tasks. For multi-task learning we train agents—each with one set of weights for all tasks—on a newly introduced collection of 30 DeepMind Lab tasks and on all 57 games of the Atari Learning Environment (Bellemare et al., 2013a).

For all the experiments we have used two different model architectures: a shallow model similar to (Mnih et al., 2016) with an LSTM before the policy and value (shown in Figure 3 (left)) and a deeper residual model (He et al., 2016) (shown in Figure 3 (right)). For tasks with a language channel we used an LSTM with text embeddings as input.

High throughput, computational efficiency and scalability are among the main design goals of IMPALA. To demonstrate that IMPALA outperforms current algorithms in these metrics we compare A3C (Mnih et al., 2016), batched A2C variations and IMPALA variants with various optimisations. For single-machine experiments using GPUs, we use dynamic batching in the forward pass to avoid several batch size 1 forward passes. Our dynamic batching module is implemented by specialised TensorFlow operations but is conceptually similar to the queues used in GA3C. Table 1 details the results for single-machine and multi-machine versions with the shallow model from Figure 3. In the single-machine case, IMPALA achieves the highest performance on both tasks, ahead of all batched A2C variants and ahead of A3C. However, the distributed, multi-machine setup is where IMPALA can really demonstrate its scalability. With the optimisations from Section 3.1 to speed up the GPU-based learner, the IMPALA agent achieves a throughput rate of 250,000 frames/sec or $21$ billion frames/day. Note, to reduce the number of actors needed per learner, one can use auxiliary losses, data from experience replay or other expensive learner-only computation.

2 Single-Task Training

To investigate IMPALA’s learning dynamics, we employ the single-task scenario where we train agents individually on 5 different DeepMind Lab tasks. The task set consists of a planning task, two maze navigation tasks, a laser tag task with scripted bots and a simple fruit collection task.

We perform hyperparameter sweeps over the weighting of entropy regularisation, the learning rate and the RMSProp epsilon. For each experiment we use an identical set of 24 pre-sampled hyperparameter combinations from the ranges in Appendix D.1 . The other hyperparameters were fixed to values specified in Appendix D.3 .

Figure 4 shows a comparison between IMPALA, A3C and batched A2C with the shallow model in Figure 3. In all of the 5 tasks, either batched A2C or IMPALA reach the best final average return and in all tasks but seekavoid_arena_01 they are ahead of A3C throughout the entire course of training. IMPALA outperforms the synchronous batched A2C on 2 out of 5 tasks while achieving much higher throughput (see Table 1). We hypothesise that this behaviour could stem from the V-trace off-policy correction acting similarly to generalised advantage estimation (Schulman et al., 2016) and asynchronous data collection yielding more diverse batches of experience.

In addition to reaching better final performance, IMPALA is also more robust to the choice of hyperparameters than A3C. Figure 4 compares the final performance of the aforementioned methods across different hyperparameter combinations, sorted by average final return from high to low. Note that IMPALA achieves higher scores over a larger number of combinations than A3C.

2.2 V-trace Analysis

To analyse V-trace we investigate four different algorithms: 1. No-correction - No off-policy correction. 2. $\varepsilon$-correction - Add a small value ($\varepsilon=1e\mbox{-}6$) during gradient calculation to prevent $\log\pi(a)$ from becoming very small and leading to numerical instabilities, similar to (Babaeizadeh et al., 2016). 3. 1-step importance sampling - No off-policy correction when optimising $V(x)$. For the policy gradient, multiply the advantage at each time step by the corresponding importance weight. This variant is similar to V-trace without “traces” and is included to investigate the importance of “traces” in V-trace. 4. V-trace as described in Section 4.

For V-trace and 1-step importance sampling we clip each importance weight $\rho_{t}$ and $c_{t}$ at $1$ (i.e. $\bar{c}=\bar{\rho}=1)$. This reduces the variance of the gradient estimate but introduces a bias. Out of $\bar{\rho}\in$ we found that $\bar{\rho}=1$ worked best.

We evaluate all algorithms on the set of 5 DeepMind Lab tasks from the previous section. We also add an experience replay buffer on the learner to increase the off-policy gap between $\pi$ and $\mu$. In the experience replay experiments we draw 50% of the items in each batch uniformly at random from the replay buffer. Table 2 shows the final performance for each algorithm with and without replay respectively. In the no replay setting, V-trace performs best on 3 out of 5 tasks, followed by 1-step importance sampling, $\varepsilon$-correction and No-correction. Although 1-step importance sampling performs similarly to V-trace in the no-replay setting, the gap widens on 4 out 5 tasks when using experience replay. This suggests that the cruder 1-step importance sampling approximation becomes insufficient as the target and behaviour policies deviate from each other more strongly. Also note that V-trace is the only variant that consistently benefits from adding experience replay. $\varepsilon$-correction improves significantly over No-correction on two tasks but lies far behind the importance-sampling based methods, particularly in the more off-policy setting with experience replay. Figure E.1 shows results of a more detailed analysis. Figure E.2 shows that the importance-sampling based methods also perform better across all hyperparameters and are typically more robust.

3 Multi-Task Training

IMPALA’s high data throughput and data efficiency allow us to train not only on one task but on multiple tasks in parallel with only a minimal change to the training setup. Instead of running the same task on all actors, we allocate a fixed number of actors to each task in the multi-task suite. Note, the model does not know which task it is being trained or evaluated on.

To test IMPALA’s performance in a multi-task setting we use DMLab-30, a set of 30 diverse tasks built on DeepMind Lab. Among the many task types in the suite are visually complex environments with natural-looking terrain, instruction-based tasks with grounded language (Hermann et al., 2017), navigation tasks, cognitive (Leibo et al., 2018) and first-person tagging tasks featuring scripted bots as opponents. A detailed description of DMLab-30 and the tasks are available at github.com/deepmind/lab and deepmind.com/dm-lab-30.

We compare multiple variants of IMPALA with a distributed A3C implementation. Except for agents using population-based training (PBT) (Jaderberg et al., 2017a), all agents are trained with hyperparameter sweeps across the same range given in Appendix D.1 . We report mean capped human normalised score where the score for each task is capped at 100% (see Appendix B ). Using mean capped human normalised score emphasises the need to solve multiple tasks instead of focusing on becoming super human on a single task. For PBT we use the mean capped human normalised score as fitness function and tune entropy cost, learning rate and RMSProp $\varepsilon$. See Appendix F for the specifics of the PBT setup.

In particular, we compare the following agent variants. A3C, deep, a distributed implementation with 210 workers (7 per task) featuring the deep residual network architecture (Figure 3 (Right)). IMPALA, shallow with 210 actors and IMPALA, deep with 150 actors both with a single learner. IMPALA, deep, PBT, the same as IMPALA, deep, but additionally using the PBT (Jaderberg et al., 2017a) for hyperparameter optimisation. Finally IMPALA, deep, PBT, 8 learners, which utilises 8 learner GPUs to maximise learning speed. We also train IMPALA agents in an expert setting, IMPALA-Experts, deep, where a separate agent is trained per task. In this case we did not optimise hyperparameters for each task separately but instead across all tasks on which the 30 expert agents were trained.

Table 3 and Figure 6 show all variants of IMPALA performing much better than the deep distributed A3C. Moreover, the deep variant of IMPALA performs better than the shallow network version not only in terms of final performance but throughout the entire training. Note in Table 3 that IMPALA, deep, PBT, 8 learners, although providing much higher throughput, reaches the same final performance as the 1 GPU IMPALA, deep, PBT in the same number of steps. Of particular importance is the gap between the IMPALA-Experts which were trained on each task individually and IMPALA, deep, PBT which was trained on all tasks at once. As Figure 6 shows, the multi-task version is outperforms IMPALA-Experts throughout training and the breakdown into individual scores in Appendix B shows positive transfer on tasks such as language tasks and laser tag tasks.

Comparing A3C to IMPALA with respect to wall clock time (Figure 6) further highlights the scalability gap between the two approaches. IMPALA with 1 learner takes only around 10 hours to reach the same performance that A3C approaches after 7.5 days. Using 8 learner GPUs instead of 1 further speeds up training of the deep model by a factor of 7 to 210K frames/sec, up from 30K frames/sec.

3.2 Atari

The Atari Learning Environment (ALE) (Bellemare et al., 2013b) has been the testing ground of most recent deep reinforcement agents. Its 57 tasks pose challenging reinforcement learning problems including exploration, planning, reactive play and complex visual input. Most games feature very different visuals and game mechanics which makes this domain particularly challenging for multi-task learning.

We train IMPALA and A3C agents on each game individually and compare their performance using the deep network (without the LSTM) introduced in Section 5. We also provide results using a shallow network that is equivalent to the feed forward network used in (Mnih et al., 2016) which features three convolutional layers. The network is provided with a short term history by stacking the 4 most recent observations at each step. For details on pre-processing and hyperparameter setup please refer to Appendix G .

In addition to individual per-game experts, trained for 200 million frames with a fixed set of hyperparameters, we train an IMPALA Atari-57 agent—one agent, one set of weights—on all 57 Atari games at once for 200 million frames per game or a total of 11.4 billion frames. For the Atari-57 agent, we use population based training with a population size of 24 to adapt entropy regularisation, learning rate, RMSProp $\varepsilon$ and the global gradient norm clipping threshold throughout training.

We compare all algorithms in terms of median human normalised score across all 57 Atari games. Evaluation follows a standard protocol, each game-score is the mean over 200 evaluation episodes, each episode was started with a random number of no-op actions (uniformly chosen from ) to combat the determinism of the ALE environment.

As table 4 shows, IMPALA experts provide both better final performance and data efficiency than their A3C counterparts in the deep and the shallow configuration. As in our DeepMind Lab experiments, the deep residual network leads to higher scores than the shallow network, irrespective of the reinforcement learning algorithm used. Note that the shallow IMPALA experiment completes training over 200 million frames in less than one hour.

We want to particularly emphasise that IMPALA, deep, multi-task, a single agent trained on all 57 ALE games at once, reaches 59.7% median human normalised score. Despite the high diversity in visual appearance and game mechanics within the ALE suite, IMPALA multi-task still manages to stay competitive to A3C, shallow, experts, commonly used as a baseline in related work. ALE is typically considered a hard multi-task environment, often accompanied by negative transfer between tasks (Rusu et al., 2016). To our knowledge, IMPALA is the first agent to be trained in a multi-task setting on all 57 games of ALE that is competitive with a standard expert baseline.

Conclusion

We have introduced a new highly scalable distributed agent, IMPALA, and a new off-policy learning algorithm, V-trace. With its simple but scalable distributed architecture, IMPALA can make efficient use of available compute at small and large scale. This directly translates to very quick turnaround for investigating new ideas and opens up unexplored opportunities.

V-trace is a general off-policy learning algorithm that is more stable and robust compared to other off-policy correction methods for actor critic agents. We have demonstrated that IMPALA achieves better performance compared to A3C variants in terms of data efficiency, stability and final performance. We have further evaluated IMPALA on the new DMLab-30 set and the Atari-57 set. To the best of our knowledge, IMPALA is the first Deep-RL agent that has been successfully tested in such large-scale multi-task settings and it has shown superior performance compared to A3C based agents (49.4% vs. 23.8% human normalised score on DMLab-30). Most importantly, our experiments on DMLab-30 show that, in the multi-task setting, positive transfer between individual tasks lead IMPALA to achieve better performance compared to the expert training setting. We believe that IMPALA provides a simple yet scalable and robust framework for building better Deep-RL agents and has the potential to enable research on new challenges.

Acknowledgements

We would like to thank Denis Teplyashin, Ricardo Barreira, Manuel Sanchez for their work improving the performance on DMLab-30 environments and Matteo Hessel, Jony Hudson, Igor Babuschkin, Max Jaderberg, Ivo Danihelka, Jacob Menick and David Silver for their comments and insightful discussions.

References

Appendix A Analysis of V-trace

Furthermore, ${\cal R}$ is a $\eta$-contraction mapping in sup-norm, with

The truncation levels $\bar{c}$ and $\bar{\rho}$ play different roles in this operator:

$\bar{\rho}$ impacts the fixed-point of the operator, thus the policy $\pi_{\bar{\rho}}$ which is evaluated. For $\bar{\rho}=\infty$ (untruncated $\rho_{t}$) we get the value function of the target policy $V^{\pi}$, whereas for finite $\bar{\rho}$, we evaluate a policy which is in between $\mu$ and $\pi$ (and when $\rho$ is close to , then we evaluate $V^{\mu}$). So the larger $\bar{\rho}$ the smaller the bias in off-policy learning. The variance naturally grows with $\bar{\rho}$. However notice that we do not take the product of those $\rho_{t}$ coefficients (in contrast to the $c_{s}$ coefficients) so the variance does not explode with the time horizon.

$\bar{c}$ impacts the contraction modulus $\eta$ of ${\cal R}$ (thus the speed at which an online-algorithm like V-trace will converge to its fixed point $V^{\pi_{\bar{\rho}}}$). In terms of variance reduction, here is it really important to truncate the importance sampling ratios in $c_{t}$ because we take the product of those. Fortunately, our result says that for any level of truncation $\bar{c}$, the fixed point (the value function $V^{\pi_{\bar{\rho}}}$ we converge to) is the same: it does not depend on $\bar{c}$ but on $\bar{\rho}$ only.

First notice that we can rewrite ${\cal R}$ as

with the notation that $c_{-1}=\rho_{-1}=1$ and $\prod_{s=0}^{t-2}c_{s}=1$ for $t=0$ and $1$. Now the coefficients $(\alpha_{t})_{t\geq 0}$ are non-negative in expectation. Indeed, since $\bar{\rho}\geq\bar{c}$, we have

since this is the Bellman equation for $V^{\pi_{\bar{\rho}}}$. We deduce that ${\cal R}V^{\pi_{\bar{\rho}}}=V^{\pi_{\bar{\rho}}}$, thus $V^{\pi_{\bar{\rho}}}$ is the unique fixed point of ${\cal R}$. ∎

A.2 Online learning

Assume a tabular representation, i.e. the state and action spaces are finite. Consider a set of trajectories, with the $k^{th}$ trajectory $x_{0},a_{0},r_{0},x_{1},a_{1},r_{1},\dots$ generated by following $\mu$: $a_{t}\sim\mu(\cdot|x_{t})$. For each state $x_{s}$ along this trajectory, update

with c_{i}=\min\big{(}\bar{c},\frac{\pi(a_{i}|x_{i})}{\mu(a_{i}|x_{i})}\big{)}, \rho_{i}=\min\big{(}\bar{\rho},\frac{\pi(a_{i}|x_{i})}{\mu(a_{i}|x_{i})}\big{)}, $\bar{\rho}\geq\bar{c}$. Assume that (1) all states are visited infinitely often, and (2) the stepsizes obey the usual Robbins-Munro conditions: for each state $x$, $\sum_{k}\alpha_{k}(x)=\infty$, $\sum_{k}\alpha_{k}^{2}(x)<\infty$. Then $V_{k}\to V^{\pi_{\bar{\rho}}}$ almost surely.

The proof is a straightforward application of the convergence result for stochastic approximation algorithms to the fixed point of a contraction operator, see e.g. (Dayan94; bertsekas1996neurodynamic; kushner2003).

which is different from $Q^{\pi_{\bar{\rho}}}(x_{s},a_{s})$ when $V^{\pi_{\bar{\rho}}}(x_{s})\neq Q^{\pi_{\bar{\rho}}}(x_{s},a_{s})$.

Appendix B Reference Scores

Appendix C Atari Scores

Appendix D Parameters

In this section, the specific parameter settings that are used throughout our experiments are given in detail.

In this section, we list all the hyperparameters that were kept fixed across all experiments in the paper which are mostly concerned with observations specifications and optimisation. We first show below the reward pre-processing function that is used across all experiments using DeepMind Lab, followed by all fixed numerical values.

Appendix E V-trace Analysis

Here we show how different algorithms (On-Policy, No-correction, $\varepsilon$-correction, V-trace) behave under varying levels of policy-lag between the actors and the learner.

E.2 V-trace Stability Analysis

E.3 Estimating the State Action Value for Policy Gradient

We investigated different ways of estimating the state action value function used to estimate advantages for the policy gradient calculation. The variant presented in the main section of the paper uses the V-trace corrected value function $v_{s+1}$ to estimate $q_{s}=r_{s}+\gamma v_{s+1}$. Another possibility is to use the actor-critic baseline $V(x_{s+1})$ to estimate $q_{s}=r_{s}+\gamma V(x_{s+1})$. Note that the latter variant does not use any information from the current policy rollout to estimate the policy gradient and relies on an accurate estimate of the value function. We found the latter variant to perform worse both when comparing the top 3 runs and an average over all runs of the hyperparameter sweep as can be see in figures E.3 and E.4.

Appendix F Population Based Training

For Population Based Training we used a “burn-in” period of 20 million frames where no evolution is done. This is to stabilise the process and to avoid very rapid initial adaptation which hinders diversity. After collecting 5,000 episode rewards in total, the mean capped human normalised score is calculated and a random instance in the population is selected. If the score of the selected instance is more than an absolute 5% higher, then the selected instance weights and parameters are copied.

No matter if a copy happened or not, each parameter (RMSProp epsilon, learning rate and entropy cost) is permuted with 33% probability by multiplying with either $1.2$ or $1/1.2$. This is different from (jaderberg2017pbt) in that our multiplication is unbiased where they use a multiplication of $1.2$ or $.8$. We found that diversity is increased when the parameters are permuted even if no copy happened.

We reconstruct the learning curves of the PBT runs in Figure 6 by backtracking through the ancestry of copied checkpoints for selected instances.

Appendix G Atari Experiments

All agents trained on Atari are equipped only with a feed forward network and pre-process frames in the same way as described in (A3C2016). When training experts agents, we use the same hyperparameters for each game for both IMPALA and A3C. These hyperparameters are the result of tuning A3C with a shallow network on the following games: breakout, pong, space_invaders, seaquest, beam_rider, qbert. Following related work, experts use game-specific action sets.

The multi-task agent was equipped with a feed forward residual network (see Figure 3 ). The learning rate, entropy regularisation, RMSProp $\varepsilon$ and gradient clipping threshold were adapted through population based training. To be able to use the same policy layer on all Atari games in the multi-task setting we train the multi-task agent on the full Atari action set consisting of 18 actions.

Agents were trained using the following set of hyperparameters:

References