Neural Replicator Dynamics

by   Shayegan Omidshafiei, et al.

In multiagent learning, agents interact in inherently nonstationary environments due to their concurrent policy updates. It is, therefore, paramount to develop and analyze algorithms that learn effectively despite these nonstationarities. A number of works have successfully conducted this analysis under the lens of evolutionary game theory (EGT), wherein a population of individuals interact and evolve based on biologically-inspired operators. These studies have mainly focused on establishing connections to value-iteration based approaches in stateless or tabular games. We extend this line of inquiry to formally establish links between EGT and policy gradient (PG) methods, which have been extensively applied in single and multiagent learning. We pinpoint weaknesses of the commonly-used softmax PG algorithm in adversarial and nonstationary settings and contrast PG's behavior to that predicted by replicator dynamics (RD), a central model in EGT. We consequently provide theoretical results that establish links between EGT and PG methods, then derive Neural Replicator Dynamics (NeuRD), a parameterized version of RD that constitutes a novel method with several advantages. First, as NeuRD reduces to the well-studied no-regret Hedge algorithm in the tabular setting, it inherits no-regret guarantees that enable convergence to equilibria in games. Second, NeuRD is shown to be more adaptive to nonstationarity, in comparison to PG, when learning in canonical games and imperfect information benchmarks including Poker. Thirdly, modifying any PG-based algorithm to use the NeuRD update rule is straightforward and incurs no added computational costs. Finally, while single-agent learning is not the main focus of the paper, we verify empirically that NeuRD is competitive in these settings with a recent baseline algorithm.


page 1

page 2

page 3

page 4


Convergence and Price of Anarchy Guarantees of the Softmax Policy Gradient in Markov Potential Games

We study the performance of policy gradient methods for the subclass of ...

Policy Optimization for Markov Games: Unified Framework and Faster Convergence

This paper studies policy optimization algorithms for multi-agent reinfo...

Evolutionary Dynamics and Φ-Regret Minimization in Games

Regret has been established as a foundational concept in online learning...

Regret Minimization and Convergence to Equilibria in General-sum Markov Games

An abundance of recent impossibility results establish that regret minim...

Competitive Policy Optimization

A core challenge in policy optimization in competitive Markov decision p...

Alternative Function Approximation Parameterizations for Solving Games: An Analysis of f-Regression Counterfactual Regret Minimization

Function approximation is a powerful approach for structuring large deci...

Interpolating Between Softmax Policy Gradient and Neural Replicator Dynamics with Capped Implicit Exploration

Neural replicator dynamics (NeuRD) is an alternative to the foundational...

Code Repositories


Evaluating EGT and RL dynamics in 3 strategies norm games

view repo

1 Introduction

In multiagent reinforcement learning (MARL), agents interact in a shared environment and aim to learn policies that maximize their returns 

(Busoniu et al., 2008; Panait and Luke, 2005; Tuyls and Weiss, 2012). The associated core challenge is that the agents’ concurrent learning implies that they each perceive the environment as nonstationary (Matignon et al., 2012; Tuyls and Weiss, 2012). It has been suggested that enabling agents to adapt to nonstationary environments, rather than merely learn static policies, is the paramount objective in multiagent learning (Shoham et al., 2007; Tuyls and Parsons, 2007). Recent works have made considerable progress in increasing the scalability of MARL algorithms and the complexity of application domains. These include approaches relying on self-play (Heinrich and Silver, 2016), regret minimization (Bowling et al., 2015; Waugh et al., 2015; Moravčík et al., 2017; Brown and Sandholm, 2017; Brown et al., 2018; Lockhart et al., 2019), and a large body of works that assume a standard centralized learning, decentralized execution paradigm (Oliehoek et al., 2016; Lowe et al., 2017; Foerster et al., 2018; Rashid et al., 2018). However, approaches such as Neural Fictitious Self-Play (NFSP) (Heinrich and Silver, 2016) and Deep CFR (Brown et al., 2018) rely on maintenance of extremely large data buffers; continual re-solving approaches such as DeepStack (Moravčík et al., 2017) and Libratus (Brown and Sandholm, 2017) are restricted to finite-horizon domains with enumerable belief spaces; and centralized learning approaches assume team-wide shared knowledge of experiences or policies. Most other works that focus on nonstationary multiagent learning are limited to repeated and stochastic games (Busoniu et al., 2008; Hernandez-Leal et al., 2017; Abdallah and Kaisers, 2016; Palmer et al., 2018b, a).

This paper focuses on model-free learning in the context of nonstationary games. Specifically, we leverage insights from evolutionary game theory (EGT) (Maynard Smith and Price, 1973; Weibull, 1997; J. Hofbauer and Sigmund, 1998) to develop our proposed algorithm. EGT models the interactions of a population of individuals that have minimal knowledge of opponent strategies or preferences, and has proven vital for not only the analysis and evaluation of MARL agents (Ponsen et al., 2009; Tuyls et al., 2018b, a; Omidshafiei et al., 2019), but also the development of novel algorithms (Tuyls et al., 2004). Links between EGT and MARL have been primarily identified between the Replicator Dynamics (RD), a standard model in EGT, and simple policy iteration algorithms such as Cross Learning and Learning Automata (Börgers and Sarin, 1997; Tuyls et al., 2006; Bloembergen et al., 2015), value-iteration algorithms such as Q-learning in stateless cases (Tuyls et al., 2003; Kaisers and Tuyls, 2010), and no-regret learning (Klos et al., 2010).

In this paper, we go beyond these simple settings and focus our analysis on the connections between EGT and Policy Gradient (PG) algorithms, which have been extensively applied to MARL (Singh et al., 2000; Bowling, 2005; Bowling and Veloso, 2002; Foerster et al., 2018; Al-Shedivat et al., 2017; Lowe et al., 2017; Srinivasan et al., 2018). We first establish links between the RD, PG methods, and online learning, enabling new interpretations of these approaches. We use these links to identify a key limitation in commonly-used softmax PG-based methods that prevents their rapid adaptation in nonstationary settings, in contrast to RD. Given this insight, we derive a new PG method, called Neural Replicator Dynamics (NeuRD). We prove that in the tabular setting, NeuRD reduces to Hedge, a well-studied no-regret learning algorithm. We then introduce a variant of NeuRD that enables model-free learning in sequential imperfect information games. We empirically evaluate NeuRD in canonical and sequential games. By including variants of each where reward spaces are nonstationary, we demonstrate that NeuRD is not only more stable when learning in fixed games, but also more adaptive under nonstationarity compared to standard PG. Moreover, though not the focus of the paper, we demonstrate that NeuRD matches state-of-the-art performance in a suite of complex stationary single-agent tasks. Critically, the conversion of standard PG-based algorithms to the NeuRD update rule is simple, involving changes to few lines of code. These features make NeuRD a strong alternative to usual PG algorithms in nonstationary environments, such as in MARL or for computing equilibria in games.

2 Preliminaries

This section briefly introduces the necessary game-theoretic and reinforcement learning background.

2.1 Game Theory

Game theory studies strategic interactions of players. A normal-form game (NFG) specifies the simultaneous interaction of players with corresponding action sets . The payoff function assigns a numerical utility to each player for each possible joint action , where for all . Let denote the -th player’s mixed strategy. The expected utility for player given strategy profile is then . The best response for player given is , where is the set of opponent policies. Profile is a Nash equilibrium if for all . A useful metric for evaluating policies is  (Lanctot et al., 2017).

2.2 Replicator Dynamics

Replicator Dynamics (RD) are a key concept from EGT, which describe how a population evolves through time based on biologically-inspired operators, such as selection and mutation (Taylor and Jonker, 1978; Taylor, 1979; J. Hofbauer and Sigmund, 1998; Zeeman, 1980, 1981). The single-population RD are defined by the following system of differential equations:


Each component of determines the proportion of an action (or pure strategy) being played in the population at time . The time derivative of each component is proportional to the difference in its expected payoff, , and the average population payoff, .

2.3 Online Learning

Online learning examines the performance of learning prediction algorithms in potentially adversarial environments. On each round, , the learner samples an action, from a discrete set of actions, , according to a policy, , and receives utility, , where

is a bounded vector provided by the environment. A typical objective is for the learner to minimize its expected

regret in hindsight for not committing to after rounds; the regret is defined as


Algorithms that guarantee their average worst-case regret goes to zero as the number of rounds increases, i.e., , are called no-regret; these algorithms learn optimal policies under fixed or stochastic environments. According to a folk theorem, the average policies of no-regret algorithms in self-play or against best responses converge to a Nash equilibrium in two-player zero-sum games (e.g., see Waugh (2009, Section 2.2.1)). This result can be extended from matrix games to sequential imperfect information games by composing learners in a tree and defining utility as counterfactual value (Zinkevich et al., 2008; Hofbauer et al., 2009). We provide background on sequential games in Appendix A for completeness.

The family of no-regret algorithms known as Follow the Regularized Leader (FoReL) (McMahan, 2011; Shalev-Shwartz and Singer, 2007a, b; McMahan et al., 2013) generalizes well-known decision making algorithms and population dynamics. For a discrete action set, , FoReL is defined through the following updates:


where is the learning rate at timestep , is the vector of action utilities observed at , and the regularizer is a convex function. Note that this algorithm assumes that the learner observes the entire action utility vector at each timestep rather than only the reward for taking a particular action. This is known as the full information or all-actions setting.

Under negative entropy regularization , policy reduces to a softmax function , where . This yields the well-known Hedge (Freund and Schapire, 1997) algorithm:


Hedge is no-regret as long as . Likewise, the continuous-time FoReL dynamics (Mertikopoulos et al., 2018) are


which in the case of entropy regularization yields RD as defined in (1) (e.g., see (Mertikopoulos et al., 2018)). This implies that RD is no-regret, thereby enjoying equilibration to Nash and convergence to the optimal prediction in the time-average.

2.4 Reinforcement Learning and Policy Gradient (PG)

In a Markov Decision Process, at each timestep

, an agent in state selects an action , receives a reward , then transitions to a new state . In the discounted infinite-horizon regime, the reinforcement learning (RL) objective is to learn a policy , which maximizes the expected return , with discount factor .

In actor-critic algorithms, one generates trajectories according to some parameterized policy

while learning to estimate the action-value function

. Temporal difference learning (Sutton and Barto, 2018) can be used to learn an action-value function estimator, , which is parameterized by . A PG algorithm then updates policy parameters in the direction of the gradient , where the quantity in square brackets is defined as the advantage, denoted , and . The advantage is analogous to regret in the online learning literature. In sample-based learning, the PG update incorporates a factor that accounts for the fact that was sampled from . The all-actions PG algorithm without this factor is then , where is a column vector of

s. While different policy parameterizations are possible, the most common choice for discrete decision problems is a softmax function over the logits,

, and we focus the rest of our analysis on this form of PG.

PG-based methods learn policies directly, handle continuous actions seamlessly, and combine readily with deep learning to solve high-dimensional tasks 

(Sutton and Barto, 2018). These benefits have, in part, led to the success of recent PG-based algorithms (e.g., A3C (Mnih et al., 2016), IMPALA (Espeholt et al., 2018), MADDPG (Lowe et al., 2017), and COMA (Foerster et al., 2018)).

3 A Unifying Perspective on Replicator Dynamics and Policy Gradient

This section motivates and introduces a novel algorithm, Neural Replicator Dynamics (NeuRD), then presents unifying theoretical results for NeuRD, online learning, RD, and PG.

3.1 Learning Dynamics under RD and PG

Let us consider the strengths and weaknesses of the algorithms described thus far. While RD and the closely-related FoReL are no-regret and enable learning of equilibria in games, they are limited in application to tabular settings. By contrast, PG is applicable to high-dimensional single and multiagent RL domains. Unfortunately, PG suffers from the fact that increasing the probability of taking an action which already has low probability mass can be very slow, in contrast to the considered no-regret algorithms. We can see this by writing out the single state, tabular, all-actions PG update explicitly, using the notation of online learning to identify the correspondences to that literature. On round

, PG updates its logits and policy as


As there is no action or state sampling in this setting, shifting all the payoffs by the expected value (or in RL terms) has no impact on the policy, so this term is omitted here. Noting that  (Sutton and Barto, 2018, Section 2.8), we observe that the update direction, , is actually the instantaneous regret scaled by , yielding the concrete update:111This scaling by is also apparent when taking the continuous-time limit of PG dynamics (see Appendix B).


See Section C.1 for details. Scaling the regret by leads to an update that can prevent PG from achieving reasonable performance in even simple environments.

(a) Replicator dynamics.
(b) PG dynamics.
(c) Comparison of dynamics speeds.
Figure 1: Learning dynamics of fig:rps_rd RD and fig:rps_qpg PG dynamics in Rock–Paper-Scissors. In fig:rps_ratio we compare the the speed of RD and PG, i.e., . When policies are near-deterministic (i.e., near the simplex boundaries), RD is notably more adaptive than PG.

The fact that the update includes a scaling factor can hinder learning in nonstationary settings (e.g., in games) when an action might be safely disregarded at first, but later the value of this action improves. We illustrate this adaptability issue in the game of Rock–Paper–Scissors, by respectively comparing the dynamics of RD and PG in Figs. 0(b) and 0(a); note the differences near the vertices, where a single action retains a majority of policy mass. Figure 0(c) compares the speeds of the dynamics by plotting the ratio . This example illustrates the practical issues that arise when using PG in settings where learning has converged to a near-deterministic policy and then must adapt to a different policy given, e.g., dynamic payoffs or opponents. While PG fails to adapt rapidly to the game at hand, RD does not exhibit this issue.

Given these insights, our objective is to derive an algorithm that combines the best of both worlds, in that it is theoretically-grounded and adaptive in the manner of RD, while still enjoying the practical benefits of the parametric PG update rule in RL applications.

3.2 NeuRD: Neural Replicator Dynamics

While we have highlighted key limitations of PG in comparison to RD, the latter has limited practicality when computational updates are inherently discrete-time or a parameterized policy is desired for generalizability. To address these limitations, we derive a discrete-time parameterized policy update rule, titled Neural Replicator Dynamics (NeuRD), which is later compared against PG. For seamless comparison of our update rule to standard PG, we next switch our nomenclature from the utilities used in online learning, , to the analogous action-values used in RL, . We write the RD (i.e., FoReL with entropy regularization) logit dynamics creftype 7 as



is the standard variance-reducing baseline 

(Sutton and Barto, 2018). Let denote the logits parameterized by . A natural way to derive a parametric update rule is to compute the Euler discretization222Given a tabular softmax policy, this definition matches the standard discrete-time RD. See Section C.5. of creftype 11,


and consider a fixed target value that the parameterized logits are adjusted toward. Specifically, one can update to minimize some choice of metric ,


In particular, minimizing the Euclidean distance yields,


which we later prove has a rigorous connection to Hedge and, thereby, inherits the no-regret guarantees that are useful in nonstationary settings such as games. As our experiments use a neural network parameterization, we refer to the update rule

creftype 16 as Neural Replicator Dynamics (NeuRD).

3.3 Properties and Unifying Theorems

Overall, NeuRD is not only practical to use as it involves a simple modification of PG with no added computational expense, but also benefits from rigorous links to algorithms with no-regret guarantees, as shown in this section. All proofs are in Appendix C.

We first consider the single state, tabular case to make a key connection to no-regret algorithms.

Theorem 1.

Single state, all-actions, tabular NeuRD is Hedge.

As a reminder, Hedge (and therefore tabular NeuRD) is no-regret, so NeuRD can be used to find optimal policies or Nash equilibria. In sequential decision making settings, ensuring no-regret requires independent learners at every decision point, and additionally a counterfactual weighting of utilities in imperfect information games (IIGs) (Zinkevich et al., 2008); for completeness, we provide the necessary background on this in Appendix A. At a high level, in IIGs the set of information states for player corresponds to a partitioning of action histories, and counterfactual values are defined as the expected player utility weighted by the product of opponent sequence probabilities. With these changes, applying NeuRD to imperfect information settings is trivial, as shown in our experiments.

These facts ensure that tabular NeuRD can be used to solve a broad class of problems where PG may fail. While these guarantees are limited to the tabular case, they constitute a principled theoretical grounding on which parameterized NeuRD is constructed.

We next formalize the connection between RD and PG, expanding beyond the scope of prior works that have considered only the links between EGT and value-iteration based algorithms (Tuyls et al., 2003; Kaisers and Tuyls, 2010).

Proposition 1.

PG is a policy-level Euler discretization approximation of continuous-time RD (i.e., computing using ), under a KL-divergence minimization criterion.

Next we establish a formal link between NeuRD and Natural Policy Gradient (NPG) (Kakade, 2002).

Proposition 2.

The NeuRD update rule creftype 16 corresponds to a naturalized policy gradient rule, in the sense that NeuRD applies a natural gradient only at the policy output level of softmax function over logits, and uses the standard gradient otherwise.

Unlike NPG, NeuRD does not require computation of the inverse Fisher information matrix, which is especially expensive when, e.g., the policy is parameterized by a large-scale neural network (Martens and Grosse, 2015).

Empirical Remarks.

As in average, the logits get incremented by the advantage, they may diverge to . To avoid numerical issues, in practice one can stop updating the logits if the gap between them exceeds a large threshold. We apply this by using the following clipped gradient in lieu of a standard gradient:


where is the indicator function, is a learning rate, and controls the allowable logits gap. This thresholding is not problematic at the policy representation level, since actions can have a probability arbitrarily close to or given a large enough . Moreover, while we have so far assumed an all-actions NeuRD update, a corresponding sample-based variant, where , is given by


where is a variance-reduction term, useful since the update rule scales inversely with action selection probability , which may be close to for certain actions.

4 Evaluation

We conduct a series of evaluations demonstrating the effectiveness of NeuRD when learning in nonstationary settings such as NFGs, standard imperfect information benchmarks, and variants of each with additional reward nonstationarity. As NeuRD involves only a simple modification of the PG update rule to improve adaptivity, we focus our comparisons against standard PG as a baseline, noting that additional benefits can be analogously gained by combining NeuRD with more intricate techniques that improve PG (e.g., variance reduction, improved exploration, or off-policy learning). Experimental procedures are detailed in Section D.1.

We consider several domains. Rock–Paper–Scissors (RPS) is a well-known canonical NFG involving two players, with a cyclic dominance among the three strategies. Goofspiel is a card game where players try to obtain point cards by bidding simultaneously. We use an imperfect information variant with 4 cards where bid cards are not revealed (Lanctot, 2013). Kuhn Poker is a game wherein each player starts with 2 chips, antes 1 chip to play, receives a face-down card from a deck of such that one card remains hidden, and either bets (raise or call) or folds until all players are in (contributed equally to the pot) or out (folded). Amongst those that are in, the player with the highest-ranked card wins the pot. In Leduc Poker (Southey et al., 2005), players instead have limitless chips, one initial private card, and ante 1 chip to play. Bets are limited to 2 and 4 chips, respectively, in the first and second round, with two raises maximum in each round. A public card is revealed before the second round. Though not the primary focus of the paper, we also provide empirical results for single-agent stationary RL tasks in Section D.3, with the key observation being that updating the recently-introduced IMPALA (Espeholt et al., 2018) agent to use the NeuRD update rule matches state-of-the-art performance.

(a) Biased RPS
(b) Leduc Poker
Figure 2: fig:nerd_vs_pg_fixed_rps NashConv of the average NeuRD and PG policies in biased RPS. fig:nerd_vs_pg_allaction_leduc NashConv of the sequence-probability average policies of tabular, all-actions, counterfactual value NeuRD and PG in two-player Leduc Poker.

We first show that the differences between NeuRD and PG detailed in Section 3.3 are more than theoretical. Consider the NashConv of the time-average NeuRD and PG tabular policies in the game of RPS, shown in Fig. 1(a). Note that by construction, NeuRD and RD are equivalent in this tabular, single-state setting. NeuRD not only converges towards the Nash equilibrium faster, but PG eventually plateaus. Consider next a more complex imperfect information setting, where Fig. 2 shows that tabular, all-actions, counterfactual value NeuRD 333This can be seen as counterfactual regret minimization (CFR) (Zinkevich et al., 2008) with Hedge, also see Brown et al. (2017). more quickly and more closely approximates a Nash equilibrium in two-player Leduc Poker than tabular, all-actions, counterfactual value PG.

(a) RPS payoff table
(a) RD dynamics
(b) Nonstationary biased RPS
Figure 3: table:rps_payoffs RPS payoffs, where the choice of induces payoff bias. fig:RD_trajectories_biased_rps RD trajectories in biased RPS with , Nash shown as red dot. fig:nonstationary_nashconv_rps Time-average policy NashConv in nonstationary RPS, with the three game phases separated by vertical dashed red lines.

We next consider modifications of our domains wherein reward functions change at specific intervals during learning, compounding the usual nonstationarities in games. Specifically, we consider games with three phases, wherein learning commences under a particular reward function, after which it switches to a different function in each phase while learning continues without the policies being reset. In biased RPS, each phase corresponds to a particular choice of the parameter in payoff tables Table 0(a); specifically, we set to 20, 0, and 20, respectively, for the three phases. This has the effect of biasing the Nash equilibrium towards one of the simplex corners (see Fig. 2(b)), then to the simplex center (Fig. 0(a)), then back again towards the corner. In Fig. 2(b), we plot the NashConv of NeuRD and PG with respect to the Nash for that particular phase. Despite the changing payoffs, the NeuRD NashConv decreases towards 0 in each of the phases, while PG again plateaus.

(a) Goofspiel
(b) Kuhn Poker
(c) Leduc Poker
Figure 4: Comparison of NeuRD and PG NashConv in nonstationary imperfect information games. Vertical red dashed lines separate the phases with different reward functions for each game.
(a) Phase I
(b) Phase II
(c) Phase III
Figure 5: Comparison of NeuRD and PG NashConv AUC in the three phases of nonstationary-reward Leduc Poker, over 40 independent trials each.

Finally, we consider imperfect information games, with the reward function being iteratively negated in each game phase for added nonstationarity, and policies parameterized using neural networks. Due to the complexity of maintaining a time-average neural network policy to ensure no-regret, we use entropy regularization to induce realtime policy convergence towards the Nash (e.g., as done by Srinivasan et al. (2018)). Figure 4 illustrates the NashConv for NeuRD and PG for the imperfect information domains considered, for an intermediate level of entropy regularization. NeuRD converges faster than PG in all three domains. Section D.2 provides full sweeps over the entropy regularization parameter; as regularization increases, so does the rate of convergence, although to a fixed point further from the Nash. In Fig. 5, we plot the NashConv area-under-the-curve (AUC) for all game phases in nonstationary Leduc, and for all entropy regularization levels. Notably, NeuRD is significantly more stable in learning than PG, even without entropy regularization. Of particular note is Phase II of the game, wherein PG fails to match NeuRD’s performance for any value of regularization.

5 Discussion

This paper rigorously investigated the links between RD and PG methods, extending prior inquiries between EGT and value-iteration based methods. The insights gained led to the introduction of a novel algorithm, NeuRD, that generalizes the no-regret Hedge algorithm and RD to utilize function approximation. NeuRD was empirically shown to better cope in highly nonstationary and adversarial settings than PG. While NeuRD represents an important extension of classical learning dynamics to utilize function approximation, Hedge and RD are also instances of the more general FoReL framework that applies to arbitrary convex decision sets and problem geometries expressed through a regularization function. This connection suggests that NeuRD could perhaps likewise be generalized to convex decision sets and various parametric forms, which would allow a general FoReL-like method to take advantage of functional representations. Moreover, as NeuRD is practical in that it involves a very simple modification of the standard PG update rule, a natural avenue for future work is to investigate NeuRD-based extensions of standard PG-based methods (e.g., A3C (Mnih et al., 2016), DDPG (Lillicrap et al., 2015), and MADDPG (Lowe et al., 2017)), in addition to naturally nonstationary single-agent RL tasks such as intrinsic motivation-based exploration (Graves et al., 2017).


  • Abdallah and Kaisers (2016) Sherief Abdallah and Michael Kaisers. Addressing environment non-stationarity by repeating q-learning updates.

    Journal of Machine Learning Research

    , 17(46):1–31, 2016.
  • Al-Shedivat et al. (2017) Maruan Al-Shedivat, Trapit Bansal, Yuri Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel. Continuous adaptation via meta-learning in nonstationary and competitive environments. arXiv preprint arXiv:1710.03641, 2017.
  • Beattie et al. (2016) 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 preprint arXiv:1612.03801, 2016.
  • Bloembergen et al. (2015) Daan Bloembergen, Karl Tuyls, Daniel Hennes, and Michael Kaisers. Evolutionary dynamics of multi-agent learning: A survey. J. Artif. Intell. Res. (JAIR), 53:659–697, 2015.
  • Börgers and Sarin (1997) Tilman Börgers and Rajiv Sarin. Learning through reinforcement and replicator dynamics. Journal of Economic Theory, 77(1):1–14, 1997.
  • Borkar (2009) Vivek S Borkar. Stochastic approximation: a dynamical systems viewpoint, volume 48. Springer, 2009.
  • Bowling (2005) Michael Bowling. Convergence and no-regret in multiagent learning. In Advances in neural information processing systems, pages 209–216, 2005.
  • Bowling and Veloso (2002) Michael Bowling and Manuela Veloso. Multiagent learning using a variable learning rate. Artificial Intelligence, 136(2):215–250, 2002.
  • Bowling et al. (2015) Michael Bowling, Neil Burch, Michael Johanson, and Oskari Tammelin. Heads-up limit hold’em poker is solved. Science, 347(6218):145–149, 2015.
  • Brown and Sandholm (2017) Noam Brown and Tuomas Sandholm. Superhuman AI for heads-up no-limit poker: Libratus beats top professionals. Science, 360(6385), December 2017.
  • Brown et al. (2017) Noam Brown, Christian Kroer, and Tuomas Sandholm. Dynamic thresholding and pruning for regret minimization. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), 2017.
  • Brown et al. (2018) Noam Brown, Adam Lerer, Sam Gross, and Tuomas Sandholm. Deep counterfactual regret minimization. CoRR, abs/1811.00164, 2018. URL
  • Burch (2017) Neil Burch. Time and Space: Why Imperfect Information Games are Hard. PhD thesis, University of Alberta, 2017.
  • Burch et al. (2019) Neil Burch, Matej Moravcik, and Martin Schmid. Revisiting cfr+ and alternating updates. Journal of Artificial Intelligence Research, 64:429–443, 2019.
  • Busoniu et al. (2008) Lucian Busoniu, Robert Babuska, and Bart De Schutter. A comprehensive survey of multiagent reinforcement learning. IEEE Trans. Systems, Man, and Cybernetics, Part C, 38(2):156–172, 2008.
  • Cressman (2003) Ross Cressman. Evolutionary Dynamics and Extensive Form Games. The MIT Press, 2003.
  • Espeholt et al. (2018) Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymir Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. arXiv preprint arXiv:1802.01561, 2018.
  • Foerster et al. (2018) Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
  • Freund and Schapire (1997) Yoav Freund and Robert E Schapire. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of computer and system sciences, 55(1):119–139, 1997.
  • Gatti et al. (2013) N. Gatti, F. Panozzo, and M. Restelli. Efficient evolutionary dynamics with extensive-form games. In Proceedings of the Twenty-Seventh AAAI Conference on Artificial Intelligence, pages 335–341, 2013.
  • Gatti and Restelli (2016) Nicola Gatti and Marcello Restelli. Sequence-form and evolutionary dynamics: Realization equivalence to agent form and logit dynamics. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence (AAAI-16), pages 509–515, 2016.
  • Graves et al. (2017) Alex Graves, Marc G Bellemare, Jacob Menick, Remi Munos, and Koray Kavukcuoglu. Automated curriculum learning for neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1311–1320. JMLR. org, 2017.
  • Heinrich and Silver (2016) Johannes Heinrich and David Silver. Deep reinforcement learning from self-play in imperfect-information games. arXiv preprint arXiv:1603.01121, 2016.
  • Hernandez-Leal et al. (2017) Pablo Hernandez-Leal, Michael Kaisers, Tim Baarslag, and Enrique Munoz de Cote. A survey of learning in multiagent environments: Dealing with non-stationarity. CoRR, abs/1707.09183, 2017.
  • Hofbauer et al. (2009) Josef Hofbauer, Sylvain Sorin, and Yannick Viossat. Time average replicator and best-reply dynamics. Mathematics of Operations Research, 34(2):263–269, 2009.
  • J. Hofbauer and Sigmund (1998) J. J. Hofbauer and K. Sigmund. Evolutionary games and population dynamics. Cambridge University Press, 1998.
  • Kaisers and Tuyls (2010) Michael Kaisers and Karl Tuyls. Frequency adjusted multi-agent q-learning. In Proceedings of the 9th International Conference on Autonomous Agents and Multiagent Systems: volume 1-Volume 1, pages 309–316. International Foundation for Autonomous Agents and Multiagent Systems, 2010.
  • Kakade (2002) Sham M Kakade. A natural policy gradient. In Advances in neural information processing systems, pages 1531–1538, 2002.
  • Klos et al. (2010) Tomas Klos, Gerrit Jan van Ahee, and Karl Tuyls. Evolutionary dynamics of regret minimization. In Machine Learning and Knowledge Discovery in Databases, European Conference, ECML PKDD 2010, Barcelona, Spain, September 20-24, 2010, Proceedings, Part II, pages 82–96, 2010.
  • Lanctot (2013) Marc Lanctot. Monte Carlo Sampling and Regret Minimization for Equilibrium Computation and Decision-Making in Large Extensive Form Games. PhD thesis, Department of Computing Science, University of Alberta, Edmonton, Alberta, Canada, June 2013.
  • Lanctot (2014) Marc Lanctot. Further developments of extensive-form replicator dynamics using the sequence-form representation. In Proceedings of the Thirteenth International Conference on Autonomous Agents and Multi-Agent Systems (AAMAS), pages 1257–1264, 2014.
  • Lanctot et al. (2017) Marc Lanctot, Vinicius Zambaldi, Audrunas Gruslys, Angeliki Lazaridou, Karl Tuyls, Julien Perolat, David Silver, and Thore Graepel. A unified game-theoretic approach to multiagent reinforcement learning. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30, pages 4190–4203. 2017.
  • Lillicrap et al. (2015) Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
  • Lockhart et al. (2019) Edward Lockhart, Marc Lanctot, Julien Pérolat, Jean-Baptiste Lespiau, Dustin Morrill, Finbarr Timbers, and Karl Tuyls. Computing approximate equilibria in sequential adversarial games by exploitability descent. CoRR, abs/1903.05614, 2019. URL
  • Lowe et al. (2017) Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pages 6379–6390, 2017.
  • Martens and Grosse (2015) James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In International conference on machine learning, pages 2408–2417, 2015.
  • Matignon et al. (2012) Laetitia Matignon, Guillaume J Laurent, and Nadine Le Fort-Piat. Independent reinforcement learners in cooperative markov games: a survey regarding coordination problems.

    The Knowledge Engineering Review

    , 27(1):1–31, 2012.
  • Maynard Smith and Price (1973) J. Maynard Smith and G. R. Price. The logic of animal conflicts. Nature, 246:15–18, 1973.
  • McMahan (2011) H Brendan McMahan. Follow-the-regularized-leader and mirror descent: Equivalence theorems and l1 regularization. 2011.
  • McMahan et al. (2013) H Brendan McMahan, Gary Holt, David Sculley, Michael Young, Dietmar Ebner, Julian Grady, Lan Nie, Todd Phillips, Eugene Davydov, Daniel Golovin, et al. Ad click prediction: a view from the trenches. In Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 1222–1230. ACM, 2013.
  • Mertikopoulos et al. (2018) Panayotis Mertikopoulos, Christos Papadimitriou, and Georgios Piliouras. Cycles in adversarial regularized learning. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2703–2717. SIAM, 2018.
  • Mnih et al. (2016) Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International conference on machine learning, pages 1928–1937, 2016.
  • Moravčík et al. (2017) Matej Moravčík, Martin Schmid, Neil Burch, Viliam Lisý, Dustin Morrill, Nolan Bard, Trevor Davis, Kevin Waugh, Michael Johanson, and Michael Bowling. Deepstack: Expert-level artificial intelligence in heads-up no-limit poker. Science, 358(6362), October 2017.
  • Oliehoek et al. (2016) Frans A Oliehoek, Christopher Amato, et al. A concise introduction to decentralized POMDPs, volume 1. Springer, 2016.
  • Omidshafiei et al. (2019) Shayegan Omidshafiei, Christos Papadimitriou, Georgios Piliouras, Karl Tuyls, Mark Rowland, Jean-Baptiste Lespiau, Wojciech M Czarnecki, Marc Lanctot, Julien Perolat, and Remi Munos. -rank: Multi-agent evaluation by evolution. arXiv preprint arXiv:1903.01373, 2019.
  • Palmer et al. (2018a) Gregory Palmer, Rahul Savani, and Karl Tuyls. Negative update intervals in deep multi-agent reinforcement learning. CoRR, abs/1809.05096, 2018a.
  • Palmer et al. (2018b) Gregory Palmer, Karl Tuyls, Daan Bloembergen, and Rahul Savani. Lenient multi-agent deep reinforcement learning. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems, AAMAS ’18, pages 443–451, 2018b.
  • Panait and Luke (2005) Liviu Panait and Sean Luke. Cooperative multi-agent learning: The state of the art. Autonomous Agents and Multi-Agent Systems, 11(3):387–434, 2005.
  • Panozzo et al. (2014) Fabio Panozzo, Nicola Gatti, and Marcello Restelli. Evolutionary dynamics of q-learning over the sequence form. In Proceedings of the Twenty-Eighth AAAI Conference on Artificial Intelligence, pages 2034–2040, 2014.
  • Ponsen et al. (2009) Marc Ponsen, Karl Tuyls, Michael Kaisers, and Jan Ramon. An evolutionary game-theoretic analysis of poker strategies. Entertainment Computing, 1(1):39–45, 2009.
  • Rashid et al. (2018) Tabish Rashid, Mikayel Samvelyan, Christian Schroeder de Witt, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: Monotonic value function factorisation for deep multi-agent reinforcement learning. arXiv preprint arXiv:1803.11485, 2018.
  • Shalev-Shwartz and Singer (2007a) Shai Shalev-Shwartz and Yoram Singer. Online learning: Theory, algorithms, and applications. 2007a.
  • Shalev-Shwartz and Singer (2007b) Shai Shalev-Shwartz and Yoram Singer. A primal-dual perspective of online learning algorithms. Machine Learning, 69(2-3):115–142, 2007b.
  • Shoham et al. (2007) Yoav Shoham, Rob Powers, and Trond Grenager. If multi-agent learning is the answer, what is the question? Artificial Intelligence, 171(7):365–377, 2007.
  • Singh et al. (2000) Satinder Singh, Michael Kearns, and Yishay Mansour. Nash convergence of gradient dynamics in general-sum games. In Proceedings of the Sixteenth conference on Uncertainty in artificial intelligence, pages 541–548. Morgan Kaufmann Publishers Inc., 2000.
  • Southey et al. (2005) Finnegan Southey, Michael Bowling, Bryce Larson, Carmelo Piccione, Neil Burch, Darse Billings, and Chris Rayner. Bayes? bluff: Opponent modelling in poker. In Proceedings of the Twenty-First Conference on Uncertainty in Artificial Intelligence (UAI-05), 2005.
  • Srinivasan et al. (2018) Sriram Srinivasan, Marc Lanctot, Vinicius Zambaldi, Julien Pérolat, Karl Tuyls, Rémi Munos, and Michael Bowling. Actor-critic policy optimization in partially observable multiagent environments. In Advances in Neural Information Processing Systems, pages 3422–3435, 2018.
  • Sutton and Barto (2018) R. Sutton and A. Barto. Reinforcement Learning: An Introduction. MIT Press, 2nd edition, 2018.
  • Taylor (1979) P. Taylor. Evolutionarily stable strategies with two types of players. Journal of Applied Probability, 16:76–83, 1979.
  • Taylor and Jonker (1978) P. Taylor and L. Jonker. Evolutionarily stable strategies and game dynamics. Mathematical Biosciences, 40:145–156, 1978.
  • Tuyls and Parsons (2007) Karl Tuyls and Simon Parsons. What evolutionary game theory tells us about multiagent learning. Artif. Intell., 171(7):406–416, 2007.
  • Tuyls and Weiss (2012) Karl Tuyls and Gerhard Weiss. Multiagent learning: Basics, challenges, and prospects. AI Magazine, 33(3):41–52, 2012.
  • Tuyls et al. (2003) Karl Tuyls, Katja Verbeeck, and Tom Lenaerts. A selection-mutation model for q-learning in multi-agent systems. In The Second International Joint Conference on Autonomous Agents & Multiagent Systems, AAMAS 2003, July 14-18, 2003, Melbourne, Victoria, Australia, Proceedings, pages 693–700, 2003.
  • Tuyls et al. (2004) Karl Tuyls, Ann Nowe, Tom Lenaerts, and Bernard Manderick. An evolutionary game theoretic perspective on learning in multi-agent systems. Synthese, 139(2):297–330, 2004.
  • Tuyls et al. (2006) Karl Tuyls, Pieter Jan’t Hoen, and Bram Vanschoenwinkel. An evolutionary dynamical analysis of multi-agent learning in iterated games. Autonomous Agents and Multi-Agent Systems, 12(1):115–153, 2006.
  • Tuyls et al. (2018a) Karl Tuyls, Julien Pérolat, Marc Lanctot, Joel Z. Leibo, and Thore Graepel. A generalised method for empirical game theoretic analysis. In AAMAS, pages 77–85. International Foundation for Autonomous Agents and Multiagent Systems Richland, SC, USA / ACM, 2018a.
  • Tuyls et al. (2018b) Karl Tuyls, Julien Perolat, Marc Lanctot, Rahul Savani, Joel Leibo, Toby Ord, Thore Graepel, and Shane Legg. Symmetric decomposition of asymmetric games. Scientific Reports, 8(1):1015, 2018b.
  • Waugh (2009) Kevin Waugh. Abstraction in large extensive games, 2009. URL
  • Waugh et al. (2015) Kevin Waugh, Dustin Morrill, J. Andrew Bagnell, and Michael Bowling. Solving games with functional regret estimation. In Proceedings of the AAAI Conference on Artificial Intelligence, 2015.
  • Weibull (1997) Jorgen Weibull. Evolutionary game theory. MIT press, 1997.
  • Zeeman (1980) E.C. Zeeman. Population dynamics from game theory. Lecture Notes in Mathematics, Global theory of dynamical systems, 819, 1980.
  • Zeeman (1981) E.C. Zeeman. Dynamics of the evolution of animal conflicts. Theoretical Biology, 89:249–270, 1981.
  • Zinkevich et al. (2008) M. Zinkevich, M. Johanson, M. Bowling, and C. Piccione. Regret minimization in games with incomplete information. In Advances in Neural Information Processing Systems 20 (NIPS 2007), 2008.

Appendix A Background on extensive-form games and counterfactual values

An extensive-form game (EFG) specifies the sequential interaction between players , where is a special player called chance or nature (also denoted as player ) who has a fixed stochastic policy that determines the transition probabilities at random events like dice rolls or the dealing of cards from a shuffled deck. Actions, , are played in turns according to a player function, , and are recorded in a history, , where is the set of all possible action sequences. To model games like Poker that require some actions to be hidden from particular players, players do not observe the game’s history directly. Instead, histories are partitioned into information states, , for each player, , according to function mapping sets of histories into information states. Player must act from without knowing which particular history led to . This requires that the set of actions in each history within an information set must match, so we can define with . A behavioral policy for player maps every

to a probability distribution over actions:

. Payoffs, , are provided to each player upon reaching a terminal history, . We assume finite games so a terminal history is always eventually reached. We denote the subset of terminal histories that share as a prefix as . For any two histories, , we use the notation to indicate that history is a prefix of .

We also define state-action values for joint policies. The value represents the expected return to player starting at state , taking action , and playing . Formally,


where is the expected utility of the ground state-action pair , and is the probability of reaching under the profile . We make the common assumption that players have perfect recall, i.e., they do not forget anything they have observed while playing. Under perfect recall, the distribution of the states can be obtained only from the opponents’ policies using Bayes’ rule (see Srinivasan et al. (2018, Section 3.2)). For convenience, in turn-based games, we define and .

The probability of reaching any history can be decomposed as the product of player sequence probabilities, . Counterfactual value (Zinkevich et al., 2008) plays a critical role in many Nash equilibrium approximation methods and is defined as the expected utility weighted by the product of opponent sequence probabilities,


with defined analogously. Policy averaging is also part of many algorithms and is done in terms of sequence probabilities in EFGs.

In this regime, the policy for player on round in information state , is


where is the learning rate at round , while and are, respectively, the counterfactual action-value and value.

Appendix B Comparison of RD and Continuous-time PG Dynamics

We can also consider the continuous-time -value based policy gradient (QPG) dynamics (Srinivasan et al., 2018, Section D.1.1), which are amenable for comparison against the RD and provide a reasonable approximation to the discrete-time PG models given a sufficiently small learning rate (Borkar, 2009):


In contrast to RD creftype 1, the QPG dynamics in creftype 22 have an additional term that modulates learning and slows adaptation for actions that are taken with low probability under .

Appendix C Proofs of theoretical results

c.1 Single state, tabular PG update

Here, we fully derive the single state, tabular PG update. On round , PG updates its logits as


As there is no action or state sampling in this setting, shifting all the payoffs by the expected value (or in RL terms) has no impact on the policy, so this term is omitted here. Noting that  (Sutton and Barto, 2018, Section 2.8), we observe that the update direction, , is actually the instantaneous regret scaled by :


Therefore, the concrete update is:


c.2 Proof of Theorem 1

See 1


In the single state, tabular case,

is the identity matrix, so unrolling the NeuRD update 

creftype 16 across rounds, we see that the NeuRD policy is


since is shift invariant. But creftype 31 is identical to creftype 5, so NeuRD and hedge use the same policy on every round and are therefore equivalent in this setting. ∎

c.3 Proof of Proposition 1

The following result unifies the Replicator Dynamics and Policy Gradient.

See 1


A discrete-time Euler discretization of the RD at the policy level is:

Note that while , this Euler-discretized update may still be outside the simplex; however, merely provides a target for our parameterized policy update, which is subsequently reprojected back to the simplex via .

Now if we consider parameterized policies , and our goal is to define dynamics on that captures those of the RD, a natural way consists in updating in order to make move towards , for example in the sense of minimizing their KL divergence, .

Of course, the KL divergence is defined only when both inputs are in the positive orthant, , so in order to measure the divergence from , which may have negative values, we need to define a KL-like divergence. Fortunately, since the is inconsequential from an optimization perspective and this is the only term that requires , a natural modification of the KL divergence to allow for negative values in its first argument is to drop this term entirely, resulting in .

The gradient-descent step on the objective is:

Assuming ,

which is precisely a policy gradient step. ∎

c.4 Proof of Proposition 2

We detail here a unification of the Natural PG and NeuRD update rules. See 2


Consider a policy defined by a softmax over a set of logits : . Define the Fisher information matrix of the policy with respect to the logits :


Note that


from the definition of . This means that considering the variables as parameters of the policy, the natural gradient of with respect to is


Now assume the logits are parameterized by some parameter (e.g., with a neural network). Let us define the pseudo-natural gradient of the probabilities with respect to as the composition of the natural gradient of with respect to (i.e., the softmax transformation) and the gradient of with respect to :


From the above, we have that a natural policy gradient yields:


which is nothing else than the NeuRD update rule in creftype 16. ∎

c.5 Equivalence to the standard discrete-time replicator dynamic

A common way to define discrete-time replicator dynamics is according to the so-called standard discrete-time replicator dynamic (Cressman, 2003),


The action values are exponentiated to ensure all the utility values are positive, which is the typical assumption required by this model. Since the policy is a softmax function applied to logits, we can rewrite this dynamic in the tabular case to also recover an equivalent to the NeuRD update rule in creftype 16 with :


is generated from logits, , which only differs from creftype 16 in a constant shift of across all actions. Since the softmax function is shift invariant, the sequence of policies generated from these update rules will be identical.

Interestingly, there have been sequence-form extensions of these standard discrete-time replicator dynamics (Gatti et al., 2013) that are also related to counterfactual regret minimization (Lanctot, 2014), but with a different (but similar) regret minimizer. There have also been a sampling variants, such as sequence-form Q-learning (Panozzo et al., 2014), and sequence-form logit dynamics (Gatti and Restelli, 2016), which seems similar to the NeuRD update. The main benefit of NeuRD over these algorithms is that using counterfactual values allows representing the policies in behavioral form, as is standard in reinforcement learning, rather than the sequence-form. As a result, it is straight-forward to do sampling and function approximation.

Appendix D Additional Experimental Remarks and Results

d.1 Experimental procedures and reproducibility notes

We detail the experimental procedures here.

For Fig. 1 we simulate the continuous time RD creftype 1 and the continuous time PG dynamics creftype 22 from regular grid points on the simplex. For Fig. 0(a) and Fig. 0(b) we plot 15 trajectories of length ; arrows indicate the direction of evolution. For Fig. 0(c) we compute for 20,000 regularly spaced points on the policy simplex.

For Fig. 1(a) the continuous time dynamics of NeuRD creftype 11 and PG creftype 22 are integrated over time with step size (equals 1 iteration). The figure shows the mean NashConv of 100 trajectories starting from initial conditions sampled uniformly from the policy simplex. The shaded area corresponds to the confidence interval computed with bootstrapping from 1000 samples.

For Fig. 1(b), in every iteration, each information-state policy over the entire game was updated for both players in an alternating fashion, i.e., the first player’s policy was updated, then the second player’s (Burch, 2017, Section 4.3.6) (Burch et al., 2019). The only difference between the NeuRD and PG algorithms in this case is the information-state logit update rule, and the only difference here–as described by creftype 10–is that PG scales the NeuRD update by the current policy. The performance displayed is that of the sequence probability time-average policy for both algorithms (see Appendix A). The set of constant step sizes tried were the same for both algorithms: . The shaded area corresponds to the interval that would result from a uniform sampling of the step size from this set.

We use the same setup detailed above for Fig. 1(a) for the nonstationary case shown in Fig. 3. The payoff matrix is switched every 1000 iterations, i.e., at and .

For each game in Fig. 4

, we randomly initialize a policy parameterized by a two-layer neural neural network (128 hidden units). Results are reported for 40 random hyperparameter sweeps for both NeuRD and PG. We update the policy once every 4 update of the Q-function. The batch size of the policy update is 256 trajectories, with trajectory lengths of 5, 8, and 8 for Kuhn Poker, Leduc Poker, and Goofspiel. The Q-function update batch size is 4 trajectories (same lengths). A learning rate of 0.002 was used for policy updates, and 0.01 for Q-value function updates. Reward function negation occurs every

learning iterations, with the three reward function phases separated by the vertical red stripes in the plots. Upon conclusion of each learning phase, policies are not reset; instead, learning continues given the latest policy (for each of the 40 trials).

For Fig. 5, we simply compute the NashConv area-under-the-curve for each phase of learning in Leduc Poker, across all entropy regularization levels, using 40 hyperparameter seeds. I.e., this plot provides a concise summary of Fig. D.6.

With the exception of the experiments presented in Section D.3, all experiments were performed on local workstations. The single-agent DMLab-30 (Beattie et al., 2016) experiments were conducted using a cloud computing platform with P100 GPUs. We performed 20 independent runs with 20 actors and one learner per run. The hyper-parameters were sampled from the same distributions as selected by Espeholt et al. (2018) with the addition of NeuRD specific hyper-parameters log-uniformly sampled in the interval and max-logit-gap uniformly in the interval .

The sample mean is used as the central tendency estimator in plots, with variation indicated as the 95% confidence interval that is the default setting used in the Seaborn visualization library that generates our plots. No data was excluded and no other preprocessing was conducted to generate these plots.

d.2 Additional imperfect information game results

Full results for all considered nonstationary imperfect information domains, under varying levels of policy entropy regularization, are shown in Figs. D.8, D.7 and D.6. Increasing policy network regularization causes the NashConv to be biased away from the Nash equilibrium. In every learning phase of every domain, the lowest NashConv over the sweep of entropy regularization coefficients is achieved by NeuRD.

(a) Regularization coefficient
(b) Regularization coefficient
(c) Regularization coefficient
(d) Regularization coefficient
(e) Regularization coefficient
(f) Regularization coefficient
(g) Regularization coefficient
(h) Regularization coefficient
(i) Regularization coefficient
(j) Regularization coefficient
(k) Regularization coefficient
Figure D.6: Comparison of NeuRD and vanilla PG in Leduc Poker with different levels of entropy regularization. The three phases corresponding to Figs. 4(c), 4(b) and 4(a) are separated by the vertical dashed red lines.
(a) Regularization coefficient
(b) Regularization coefficient
(c) Regularization coefficient
(d) Regularization coefficient
(e) Regularization coefficient
(f) Regularization coefficient
(g) Regularization coefficient
(h) Regularization coefficient
(i) Regularization coefficient
(j) Regularization coefficient
(k) Regularization coefficient
Figure D.7: Comparison of NeuRD and vanilla PG in Kuhn Poker with different levels of entropy regularization. The three game phases (each with a different reward function) are separated by the vertical dashed red lines.
(a) Regularization coefficient
(b) Regularization coefficient
(c) Regularization coefficient
(d) Regularization coefficient
(e) Regularization coefficient
(f) Regularization coefficient
(g) Regularization coefficient
(h) Regularization coefficient
(i) Regularization coefficient
(j) Regularization coefficient
(k) Regularization coefficient
Figure D.8: Comparison of NeuRD and vanilla PG in Goofspiel with different levels of entropy regularization. The three game phases (each with a different reward function) are separated by the vertical dashed red lines.

d.3 Single agent RL experiments

Though not considered a main focus in this paper, we also explore how NeuRD behaves in the single agent stationary RL setting. Specifically, we consider IMPALA (Espeholt et al., 2018), a state-of-the-art policy gradient based distributed learning agent, as a baseline. We replace the IMPALA policy update rule with that of NeuRD, otherwise keeping the training procedures the same as those used by Espeholt et al. (2018). We then compare the two algorithms in a suite of DMLab-30 (Beattie et al., 2016) tasks. All IMPALA scores correspond to the ‘experts’ (i.e., non-multitask) results reported by Espeholt et al. (2018, Table B.1).

Of particular note is the rooms_select_nonmatching_object domain, where NeuRD attains a score of , which is significantly higher than IMPALA’s score of

. We conjecture this is due to the inherent adaptivity required on behalf of the agent to maximize its reward. In this domain, the agent spawns in a room, and views an out-of-reach object shown in one of two displays. If the agent reaches a specific pad in the room, it receives a

reward, and is spawned to a second room with two objects, one of which was the one in the previous room. The agent receives a reward of (respectively, ) if it collects object not matching (respectively, matching) the one in the previous room, then respawns to the first room. The episode ends after 12 seconds. This domain can be viewed as a contextual two-arm bandit problem, where the agent needs to learn to choose the non-matching object based on the context provided in the first room, rather than converge to a deterministic policy that always chooses the object that yielded the first reward. We, therefore, conjecture that the adaptivity properties of NeuRD enable it to attain the high reward in contrast to IMPALA. These preliminary results indicate that investigation of NeuRD’s performance in related nonstationary single-agent settings may make for an interesting avenue of future work.

Figure D.9: NeuRD learning curves in single-agent stationary RL, for various DMLab-30 domains. Results reported for 20 hyperparameter seeds, with raw performance of top-3 seeds in dark blue, mean performance of top-3 seeds in red, and remaining seeds in light blue.
Level name Human Random IMPALA NeuRD
ooms_select_nonmatching_object & 65.9 & 0.3 & 7.3 & 48.9$\pm$4.0 \\
b rooms_watermaze
54.0 4.1 26.9 29.80.4
ooms_keys_doos_puzzle 53.8 4.1 28.0 24.21.2
asertag_one_opponent_smal 18.6 -0.1 -0.1 0.00.0
asertag_three_opponents_smal 31.5 -0.1 19.1 0.00.0
asertag_one_opponent_arge 12.7 -0.2 -0.2 0.00.0
asertag_three_opponents_arge 18.6 -0.2 -0.1 0.00.0
xplor_goal_locations_small 267.5 7.7 209.4 208.60.4
xplor_object_locations_small 74.5 3.6 57.8 54.00.4
xplor_object_locations_large 65.7 4.7 37.0 42.80.8
atlab_fixed_large_map & 36.9 & 2.2 & 34.7 & 22.5$\pm$4.6 \\
24.4 3.0 20.7 22.60.7
atlab_varyig_map_randomized 42.4 7.3 36.1 37.21.3
sychlab_arbitrary_visuomotor_maping 58.8 0.2 16.4 16.50.6
sychlab_continuous_recognition & 58.3 & 0.2 & 29.9 & 30.7$\m
sychlab_sequential_comarison 39.5 0.1 0.0 0.00.0
Table 1: Comparison of IMPALA and NeuRD performance in single-agent stationary RL, for various DMLab-30 domains. Both trained for environment frames in each domain. Human and random results are those reported by Espeholt et al. (2018). IMPALA scores correspond to the ‘experts’ (i.e., non-multitask) results reported by Espeholt et al. (2018, Table B.1). NeuRD scores are reported for top-3 of 20 hyperparameter seeds.