1 Introduction
Reinforcement learning (RL) has recently been applied to solve challenging problems, from game playing mnih2015human ; alphago to robotics levine2015end . In industrial applications, RL is emerging as a practical component in large scale systems such as data center cooling googleblog . Most of the successes of RL have been in single agent domains, where modelling or predicting the behaviour of other actors in the environment is largely unnecessary.
However, there are a number of important applications that involve interaction between multiple agents, where emergent behavior and complexity arise from agents coevolving together. For example, multirobot control matignon12coordinated , the discovery of communication and language sukhbaatar2016learning ; foerster16b ; mordatch2017emergence , multiplayer games peng17starcraft , and the analysis of social dilemmas multiagent_ssd all operate in a multiagent domain. Related problems, such as variants of hierarchical reinforcement learning dayan93feudal can also be seen as a multiagent system, with multiple levels of hierarchy being equivalent to multiple agents. Additionally, multiagent selfplay has recently been shown to be a useful training paradigm alphago ; sukhbaatar2017intrinsic
. Successfully scaling RL to environments with multiple agents is crucial to building artificially intelligent systems that can productively interact with humans and each other.
Unfortunately, traditional reinforcement learning approaches such as QLearning or policy gradient are poorly suited to multiagent environments. One issue is that each agent’s policy is changing as training progresses, and the environment becomes nonstationary from the perspective of any individual agent (in a way that is not explainable by changes in the agent’s own policy). This presents learning stability challenges and prevents the straightforward use of past experience replay, which is crucial for stabilizing deep Qlearning. Policy gradient methods, on the other hand, usually exhibit very high variance when coordination of multiple agents is required. Alternatively, one can use modelbased policy optimization which can learn optimal policies via backpropagation, but this requires a (differentiable) model of the world dynamics and assumptions about the interactions between agents. Applying these methods to competitive environments is also challenging from an optimization perspective, as evidenced by the notorious instability of adversarial training methods goodfellow2014generative .
In this work, we propose a generalpurpose multiagent learning algorithm that: (1) leads to learned policies that only use local information (i.e. their own observations) at execution time, (2) does not assume a differentiable model of the environment dynamics or any particular structure on the communication method between agents, and (3) is applicable not only to cooperative interaction but to competitive or mixed interaction involving both physical and communicative behavior. The ability to act in mixed cooperativecompetitive environments may be critical for intelligent agents; while competitive training provides a natural curriculum for learning sukhbaatar2017intrinsic , agents must also exhibit cooperative behavior (e.g. with humans) at execution time.
We adopt the framework of centralized training with decentralized execution, allowing the policies to use extra information to ease training, so long as this information is not used at test time. It is unnatural to do this with Qlearning without making additional assumptions about the structure of the environment, as the Q function generally cannot contain different information at training and test time. Thus, we propose a simple extension of actorcritic policy gradient methods where the critic is augmented with extra information about the policies of other agents, while the actor only has access to local information. After training is completed, only the local actors are used at execution phase, acting in a decentralized manner and equally applicable in cooperative and competitive settings.
Since the centralized critic function explicitly uses the decisionmaking policies of other agents, we additionally show that agents can learn approximate models of other agents online and effectively use them in their own policy learning procedure. We also introduce a method to improve the stability of multiagent policies by training agents with an ensemble of policies, thus requiring robust interaction with a variety of collaborator and competitor policies. We empirically show the success of our approach compared to existing methods in cooperative as well as competitive scenarios, where agent populations are able to discover complex physical and communicative coordination strategies.
2 Related Work
The simplest approach to learning in multiagent settings is to use independently learning agents. This was attempted with Qlearning in tan93multi , but does not perform well in practice matignon12independent . As we will show, independentlylearning policy gradient methods also perform poorly. One issue is that each agent’s policy changes during training, resulting in a nonstationary environment and preventing the naïve application of experience replay. Previous work has attempted to address this by inputting other agent’s policy parameters to the Q function hyper_q , explicitly adding the iteration index to the replay buffer, or using importance sampling foerster_nonstat . Deep Qlearning approaches have previously been investigated in tampuu2017multiagent to train competing Pong agents.
The nature of interaction between agents can either be cooperative, competitive, or both and many algorithms are designed only for a particular nature of interaction. Most studied are cooperative settings, with strategies such as optimistic and hysteretic Q function updates lauer00distributed ; hyst07 ; hyst17 , which assume that the actions of other agents are made to improve collective reward. Another approach is to indirectly arrive at cooperation via sharing of policy parameters gupta17cooperative , but this requires homogeneous agent capabilities. These algorithms are generally not applicable in competitive or mixed settings. See panait05 ; busoniu2008comprehensive for surveys of multiagent learning approaches and applications.
Concurrently to our work, foerster2017counterfactual proposed a similar idea of using policy gradient methods with a centralized critic, and test their approach on a StarCraft micromanagement task. Their approach differs from ours in the following ways: (1) they learn a single centralized critic for all agents, whereas we learn a centralized critic for each agent, allowing for agents with differing reward functions including competitive scenarios, (2) we consider environments with explicit communication between agents, (3) they combine recurrent policies with feedforward critics, whereas our experiments use feedforward policies (although our methods are applicable to recurrent policies), (4) we learn continuous policies whereas they learn discrete policies.
Recent work has focused on learning grounded cooperative communication protocols between agents to solve various tasks sukhbaatar2016learning ; foerster16b ; mordatch2017emergence . However, these methods are usually only applicable when the communication between agents is carried out over a dedicated, differentiable communication channel.
Our method requires explicitly modeling decisionmaking process of other agents. The importance of such modeling has been recognized by both reinforcement learning boutilier96 ; boutilier03 and cognitive science communities frank_rsa . hu98 stressed the importance of being robust to the decision making process of other agents, as do others by building Bayesian models of decision making. We incorporate such robustness considerations by requiring that agents interact successfully with an ensemble of any possible policies of other agents, improving training stability and robustness of agents after training.
3 Background
Markov Games
In this work, we consider a multiagent extension of Markov decision processes (MDPs) called partially observable Markov games
littman1994markov . A Markov game for agents is defined by a set of states describing the possible configurations of all agents, a set of actions and a set of observations for each agent. To choose actions, each agent uses a stochastic policy , which produces the next state according to the state transition function .^{1}^{1}1To minimize notation we will often omit from the subscript of . Each agent obtains rewards as a function of the state and agent’s action , and receives a private observation correlated with the state . The initial states are determined by a distribution . Each agent aims to maximize its own total expected return where is a discount factor and is the time horizon.QLearning and Deep QNetworks (DQN).
QLearning and DQN mnih2015human are popular methods in reinforcement learning and have been previously applied to multiagent settings foerster16b ; hyper_q . QLearning makes use of an actionvalue function for policy as . This Q function can be recursively rewritten as . DQN learns the actionvalue function corresponding to the optimal policy by minimizing the loss:
(1) 
where is a target Q function whose parameters are periodically updated with the most recent , which helps stabilize learning. Another crucial component of stabilizing DQN is the use of an experience replay buffer containing tuples .
QLearning can be directly applied to multiagent settings by having each agent learn an independently optimal function tan93multi . However, because agents are independently updating their policies as learning progresses, the environment appears nonstationary from the view of any one agent, violating Markov assumptions required for convergence of Qlearning. Another difficulty observed in foerster_nonstat is that the experience replay buffer cannot be used in such a setting since in general, when any .
Policy Gradient (PG) Algorithms.
Policy gradient methods are another popular choice for a variety of RL tasks. The main idea is to directly adjust the parameters of the policy in order to maximize the objective by taking steps in the direction of . Using the Q function defined previously, the gradient of the policy can be written as sutton2000policy :
(2) 
where
is the state distribution. The policy gradient theorem has given rise to several practical algorithms, which often differ in how they estimate
. For example, one can simply use a sample return , which leads to the REINFORCE algorithm williams1992simple . Alternatively, one could learn an approximation of the true actionvalue function by e.g. temporaldifference learning sutton1998reinforcement ; this is called the critic and leads to a variety of actorcritic algorithms sutton1998reinforcement .Policy gradient methods are known to exhibit high variance gradient estimates. This is exacerbated in multiagent settings; since an agent’s reward usually depends on the actions of many agents, the reward conditioned only on the agent’s own actions (when the actions of other agents are not considered in the agent’s optimization process) exhibits much more variability, thereby increasing the variance of its gradients. Below, we show a simple setting where the probability of taking a gradient step in the correct direction decreases exponentially with the number of agents.
Proposition 1.
Consider agents with binary actions: , where . We assume an uninformed scenario, in which agents are initialized to . Then, if we are estimating the gradient of the cost with policy gradient, we have:
where is the policy gradient estimator from a single sample, and is the true gradient.
Proof.
See Appendix. ∎
The use of baselines, such as value function baselines typically used to ameliorate high variance, is problematic in multiagent settings due to the nonstationarity issues mentioned previously.
Deterministic Policy Gradient (DPG) Algorithms.
It is also possible to extend the policy gradient framework to deterministic policies silver2014deterministic. In particular, under certain conditions we can write the gradient of the objective as:
(3) 
Since this theorem relies on , it requires that the action space (and thus the policy ) be continuous.
Deep deterministic policy gradient (DDPG) lillicrap2015continuous is a variant of DPG where the policy and critic
are approximated with deep neural networks. DDPG is an offpolicy algorithm, and samples trajectories from a replay buffer of experiences that are stored throughout training. DDPG also makes use of a target network, as in DQN
mnih2015human . Deep deterministic policy gradient (DDPG) lillicrap2015continuous is a variant of DPG where the policy and critic are approximated with deep neural networks. DDPG is an offpolicy algorithm, and samples trajectories from a replay buffer of experiences that are stored throughout training. DDPG also makes use of a target network, as in DQN mnih2015human .4 Methods
4.1 MultiAgent Actor Critic
We have argued in the previous section that naïve policy gradient methods perform poorly in simple multiagent settings, and this is supported in our experiments in Section 5. Our goal in this section is to derive an algorithm that works well in such settings. However, we would like to operate under the following constraints: (1) the learned policies can only use local information (i.e. their own observations) at execution time, (2) we do not assume a differentiable model of the environment dynamics, unlike in mordatch2017emergence , and (3) we do not assume any particular structure on the communication method between agents (that is, we don’t assume a differentiable communication channel). Fulfilling the above desiderata would provide a generalpurpose multiagent learning algorithm that could be applied not just to cooperative games with explicit communication channels, but competitive games and games involving only physical interactions between agents.
Similarly to foerster16b , we accomplish our goal by adopting the framework of centralized training with decentralized execution. Thus, we allow the policies to use extra information to ease training, so long as this information is not used at test time. It is unnatural to do this with Qlearning, as the Q function generally cannot contain different information at training and test time. Thus, we propose a simple extension of actorcritic policy gradient methods where the critic is augmented with extra information about the policies of other agents.
More concretely, consider a game with agents with policies parameterized by , and let be the set of all agent policies. Then we can write the gradient of the expected return for agent , as:
(4) 
Here is a centralized actionvalue function that takes as input the actions of all agents, , in addition to some state information , and outputs the Qvalue for agent . In the simplest case, could consist of the observations of all agents, , however we could also include additional state information if available. Since each is learned separately, agents can have arbitrary reward structures, including conflicting rewards in a competitive setting.
We can extend the above idea to work with deterministic policies. If we now consider continuous policies w.r.t. parameters (abbreviated as ), the gradient can be written as:
(5) 
Here the experience replay buffer contains the tuples , recording experiences of all agents. The centralized actionvalue function is updated as:
(6) 
where is the set of target policies with delayed parameters . As shown in Section 5, we find the centralized critic with deterministic policies works very well in practice, and refer to it as multiagent deep deterministic policy gradient (MADDPG). We provide the description of the full algorithm in the Appendix.
A primary motivation behind MADDPG is that, if we know the actions taken by all agents, the environment is stationary even as the policies change, since for any . This is not the case if we do not explicitly condition on the actions of other agents, as done for most traditional RL methods.
Note that we require the policies of other agents to apply an update in Eq. 6. Knowing the observations and policies of other agents is not a particularly restrictive assumption; if our goal is to train agents to exhibit complex communicative behaviour in simulation, this information is often available to all agents. However, we can relax this assumption if necessary by learning the policies of other agents from observations — we describe a method of doing this in Section 4.2.
4.2 Inferring Policies of Other Agents
To remove the assumption of knowing other agents’ policies, as required in Eq. 6, each agent can additionally maintain an approximation (where are the parameters of the approximation; henceforth ) to the true policy of agent , . This approximate policy is learned by maximizing the log probability of agent ’s actions, with an entropy regularizer:
(7) 
where is the entropy of the policy distribution. With the approximate policies, in Eq. 6 can be replaced by an approximate value calculated as follows:
(8) 
where denotes the target network for the approximate policy . Note that Eq. 7 can be optimized in a completely online fashion: before updating , the centralized Q function, we take the latest samples of each agent from the replay buffer to perform a single gradient step to update . Note also that, in the above equation, we input the action log probabilities of each agent directly into , rather than sampling.
4.3 Agents with Policy Ensembles
As previously mentioned, a recurring problem in multiagent reinforcement learning is the environment nonstationarity due to the agents’ changing policies. This is particularly true in competitive settings, where agents can derive a strong policy by overfitting to the behavior of their competitors. Such policies are undesirable as they are brittle and may fail when the competitors alter strategies.
To obtain multiagent policies that are more robust to changes in the policy of competing agents, we propose to train a collection of different subpolicies. At each episode, we randomly select one particular subpolicy for each agent to execute. Suppose that policy is an ensemble of different subpolicies with subpolicy denoted by (denoted as ). For agent , we are then maximizing the ensemble objective:
Since different subpolicies will be executed in different episodes, we maintain a replay buffer for each subpolicy of agent . Accordingly, we can derive the gradient of the ensemble objective with respect to as follows:
(9) 
5 Experiments^{1}^{1}1 Videos of our experimental results can be viewed at https://sites.google.com/site/multiagentac/
5.1 Environments
To perform our experiments, we adopt the grounded communication environment proposed in mordatch2017emergence ^{2}^{2}2Code can be found here at https://github.com/openai/multiagentparticleenvs, which consists of agents and landmarks inhabiting a twodimensional world with continuous space and discrete time. Agents may take physical actions in the environment and communication actions that get broadcasted to other agents. Unlike mordatch2017emergence , we do not assume that all agents have identical action and observation spaces, or act according to the same policy . We also consider games that are both cooperative (all agents must maximize a shared return) and competitive (agents have conflicting goals). Some environments require explicit communication between agents in order to achieve the best reward, while in other environments agents can only perform physical actions. We provide details for each environment below.
Cooperative communication. This task consists of two cooperative agents, a speaker and a listener, who are placed in an environment with three landmarks of differing colors. At each episode, the listener must navigate to a landmark of a particular color, and obtains reward based on its distance to the correct landmark. However, while the listener can observe the relative position and color of the landmarks, it does not know which landmark it must navigate to. Conversely, the speaker’s observation consists of the correct landmark color, and it can produce a communication output at each time step which is observed by the listener. Thus, the speaker must learn to output the landmark colour based on the motions of the listener. Although this problem is relatively simple, as we show in Section 5.2 it poses a significant challenge to traditional RL algorithms.
Cooperative navigation. In this environment, agents must cooperate through physical actions to reach a set of landmarks. Agents observe the relative positions of other agents and landmarks, and are collectively rewarded based on the proximity of any agent to each landmark. In other words, the agents have to ‘cover’ all of the landmarks. Further, the agents occupy significant physical space and are penalized when colliding with each other. Our agents learn to infer the landmark they must cover, and move there while avoiding other agents.
Keepaway. This scenario consists of landmarks including a target landmark, cooperating agents who know the target landmark and are rewarded based on their distance to the target, and adversarial agents who must prevent the cooperating agents from reaching the target. Adversaries accomplish this by physically pushing the agents away from the landmark, temporarily occupying it. While the adversaries are also rewarded based on their distance to the target landmark, they do not know the correct target; this must be inferred from the movements of the agents.
Physical deception. Here, agents cooperate to reach a single target landmark from a total of landmarks. They are rewarded based on the minimum distance of any agent to the target (so only one agent needs to reach the target landmark). However, a lone adversary also desires to reach the target landmark; the catch is that the adversary does not know which of the landmarks is the correct one. Thus the cooperating agents, who are penalized based on the adversary distance to the target, learn to spread out and cover all landmarks so as to deceive the adversary.
Predatorprey. In this variant of the classic predatorprey game, slower cooperating agents must chase the faster adversary around a randomly generated environment with large landmarks impeding the way. Each time the cooperative agents collide with an adversary, the agents are rewarded while the adversary is penalized. Agents observe the relative positions and velocities of the agents, and the positions of the landmarks.
Covert communication. This is an adversarial communication environment, where a speaker agent (‘Alice’) must communicate a message to a listener agent (‘Bob’), who must reconstruct the message at the other end. However, an adversarial agent (‘Eve’) is also observing the channel, and wants to reconstruct the message — Alice and Bob are penalized based on Eve’s reconstruction, and thus Alice must encode her message using a randomly generated key, known only to Alice and Bob. This is similar to the cryptography environment considered in abadi2016learning .
5.2 Comparison to Decentralized Reinforcement Learning Methods
We implement our MADDPG algorithm and evaluate it on the environments presented in Section 5.1
. Unless otherwise specified, our policies are parameterized by a twolayer ReLU MLP with 64 units per layer. To support discrete communication messages, we use the GumbelSoftmax estimator
jang2016categorical . To evaluate the quality of policies learned in competitive settings, we pitch MADDPG agents against DDPG agents, and compare the resulting success of the agents and adversaries in the environment. We train our models until convergence, and then evaluate them by averaging various metrics for 1000 further iterations. We provide the tables and details of our results on all environments in the Appendix, and summarize them here.We first examine the cooperative communication scenario. Despite the simplicity of the task (the speaker only needs to learn to output its observation), traditional RL methods such as DQN, ActorCritic, a firstorder implementation of TRPO, and DDPG all fail to learn the correct behaviour (measured by whether the listener is within a short distance from the target landmark). In practice we observed that the listener learns to ignore the speaker and simply moves to the middle of all observed landmarks. We plot the learning curves over 25000 episodes for various approaches in Figure 4.


We hypothesize that a primary reason for the failure of traditional RL methods in this (and other) multiagent settings is the lack of a consistent gradient signal. For example, if the speaker utters the correct symbol while the listener moves in the wrong direction, the speaker is penalized. This problem is exacerbated as the number of time steps grows: we observed that traditional policy gradient methods can learn when the objective of the listener is simply to reconstruct the observation of the speaker in a single time step, or if the initial positions of agents and landmarks are fixed and evenly distributed. This indicates that many of the multiagent methods previously proposed for scenarios with short time horizons (e.g. lazaridou2016multi ) may not generalize to more complex tasks.
Conversely, MADDPG agents can learn coordinated behaviour more easily via the centralized critic. In the cooperative communication environment, MADDPG is able to reliably learn the correct listener and speaker policies, and the listener is often (84.0% of the time) able to navigate to the target.
A similar situation arises for the physical deception task: when the cooperating agents are trained with MADDPG, they are able to successfully deceive the adversary by covering all of the landmarks around 94% of the time when (Figure 5). Furthermore, the adversary success is quite low, especially when the adversary is trained with DDPG (16.4% when ). This contrasts sharply with the behaviour learned by the cooperating DDPG agents, who are unable to deceive MADDPG adversaries in any scenario, and do not even deceive other DDPG agents when .
While the cooperative navigation and predatorprey tasks have a less stark divide between success and failure, in both cases the MADDPG agents outperform the DDPG agents. In cooperative navigation, MADDPG agents have a slightly smaller average distance to each landmark, but have almost half the average number of collisions per episode (when ) compared to DDPG agents due to the ease of coordination. Similarly, MADDPG predators are far more successful at chasing DDPG prey (16.1 collisions/episode) than the converse (10.3 collisions/episode).
In the covert communication environment, we found that Bob trained with both MADDPG and DDPG outperforms Eve in terms of reconstructing Alice’s message. However, Bob trained with MADDPG achieves a larger relative success rate compared with DDPG (52.4% to 25.1%). Further, only Alice trained with MADDPG can encode her message such that Eve achieves nearrandom reconstruction accuracy. The learning curve (a sample plot is shown in Appendix) shows that the oscillation due to the competitive nature of the environment often cannot be overcome with common decentralized RL methods. We emphasize that we do not use any of the tricks required for the cryptography environment from abadi2016learning
, including modifying Eve’s loss function, alternating agent and adversary training, and using a hybrid ‘mix & transform’ feedforward and convolutional architecture.
5.3 Effect of Learning Polices of Other Agents
We evaluate the effectiveness of learning the policies of other agents in the cooperative communication environment, following the same hyperparameters as the previous experiments and setting
in Eq. 7. The results are shown in Figure 7. We observe that despite not fitting the policies of other agents perfectly (in particular, the approximate listener policy learned by the speaker has a fairly large KL divergence to the true policy), learning with approximated policies is able to achieve the same success rate as using the true policy, without a significant slowdown in convergence.5.4 Effect of Training with Policy Ensembles
We focus on the effectiveness of policy ensembles in competitive environments, including keepaway, cooperative navigation, and predatorprey. We choose subpolicies for the keepaway and cooperative navigation environments, and for predatorprey. To improve convergence speed, we enforce that the cooperative agents should have the same policies at each episode, and similarly for the adversaries. To evaluate the approach, we measure the performance of ensemble policies and single policies in the roles of both agent and adversary. The results are shown on the right side of Figure 3. We observe that agents with policy ensembles are stronger than those with a single policy. In particular, when pitting ensemble agents against single policy adversaries (second to left bar cluster), the ensemble agents outperform the adversaries by a large margin compared to when the roles are reversed (third to left bar cluster).
6 Conclusions and Future Work
We have proposed a multiagent policy gradient algorithm where agents learn a centralized critic based on the observations and actions of all agents. Empirically, our method outperforms traditional RL algorithms on a variety of cooperative and competitive multiagent environments. We can further improve the performance of our method by training agents with an ensemble of policies, an approach we believe to be generally applicable to any multiagent algorithm.
One downside to our approach is that the input space of grows linearly (depending on what information is contained in ) with the number of agents . This could be remedied in practice by, for example, having a modular Q function that only considers agents in a certain neighborhood of a given agent. We leave this investigation to future work.
Acknowledgements
The authors would like to thank Jacob Andreas, Smitha Milli, Jack Clark, Jakob Foerster, and others at OpenAI and UC Berkeley for interesting discussions related to this paper, as well as Jakub Pachocki, Yura Burda, and Joelle Pineau for comments on the paper draft. We thank Tambet Matiisen for providing the code base that was used for some early experiments associated with this paper. Ryan Lowe is supported in part by a Vanier CGS Scholarship and the Samsung Advanced Institute of Technology. Finally, we’d like to thank OpenAI for fostering an engaging and productive research environment.
References
 [1] DeepMind AI reduces google data centre cooling bill by 40. https://deepmind.com/blog/deepmindaireducesgoogledatacentrecoolingbill40/. Accessed: 20170519.
 [2] M. Abadi and D. G. Andersen. Learning to protect communications with adversarial neural cryptography. arXiv preprint arXiv:1610.06918, 2016.
 [3] C. Boutilier. Learning conventions in multiagent stochastic domains using likelihood estimates. In Proceedings of the Twelfth international conference on Uncertainty in artificial intelligence, pages 106–114. Morgan Kaufmann Publishers Inc., 1996.
 [4] L. Busoniu, R. Babuska, and B. De Schutter. A comprehensive survey of multiagent reinforcement learning. IEEE Transactions on Systems Man and Cybernetics Part C Applications and Reviews, 38(2):156, 2008.
 [5] G. Chalkiadakis and C. Boutilier. Coordination in multiagent reinforcement learning: a bayesian approach. In Proceedings of the second international joint conference on Autonomous agents and multiagent systems, pages 709–716. ACM, 2003.
 [6] P. Dayan and G. E. Hinton. Feudal reinforcement learning. In Advances in neural information processing systems, pages 271–271. Morgan Kaufmann Publishers, 1993.
 [7] J. Foerster, G. Farquhar, T. Afouras, N. Nardelli, and S. Whiteson. Counterfactual multiagent policy gradients. arXiv preprint arXiv:1705.08926, 2017.
 [8] J. N. Foerster, Y. M. Assael, N. de Freitas, and S. Whiteson. Learning to communicate with deep multiagent reinforcement learning. CoRR, abs/1605.06676, 2016.
 [9] J. N. Foerster, N. Nardelli, G. Farquhar, P. H. S. Torr, P. Kohli, and S. Whiteson. Stabilising experience replay for deep multiagent reinforcement learning. CoRR, abs/1702.08887, 2017.
 [10] M. C. Frank and N. D. Goodman. Predicting pragmatic reasoning in language games. Science, 336(6084):998–998, 2012.
 [11] I. Goodfellow, J. PougetAbadie, M. Mirza, B. Xu, D. WardeFarley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.
 [12] J. K. Gupta, M. Egorov, and M. Kochenderfer. Cooperative multiagent control using deep reinforcement learning. 2017.
 [13] J. Hu and M. P. Wellman. Online learning about other agents in a dynamic multiagent system. In Proceedings of the Second International Conference on Autonomous Agents, AGENTS ’98, pages 239–246, New York, NY, USA, 1998. ACM.
 [14] E. Jang, S. Gu, and B. Poole. Categorical reparameterization with gumbelsoftmax. arXiv preprint arXiv:1611.01144, 2016.

[15]
M. Lauer and M. Riedmiller.
An algorithm for distributed reinforcement learning in cooperative
multiagent systems.
In
In Proceedings of the Seventeenth International Conference on Machine Learning
, pages 535–542. Morgan Kaufmann, 2000.  [16] A. Lazaridou, A. Peysakhovich, and M. Baroni. Multiagent cooperation and the emergence of (natural) language. arXiv preprint arXiv:1612.07182, 2016.
 [17] J. Z. Leibo, V. F. Zambaldi, M. Lanctot, J. Marecki, and T. Graepel. Multiagent reinforcement learning in sequential social dilemmas. CoRR, abs/1702.03037, 2017.
 [18] S. Levine, C. Finn, T. Darrell, and P. Abbeel. Endtoend training of deep visuomotor policies. arXiv preprint arXiv:1504.00702, 2015.
 [19] M. L. Littman. Markov games as a framework for multiagent reinforcement learning. In Proceedings of the eleventh international conference on machine learning, volume 157, pages 157–163, 1994.
 [20] L. Matignon, L. Jeanpierre, A.I. Mouaddib, et al. Coordinated multirobot exploration under communication constraints using decentralized markov decision processes. In AAAI, 2012.
 [21] L. Matignon, G. J. Laurent, and N. Le FortPiat. Hysteretic qlearning: an algorithm for decentralized reinforcement learning in cooperative multiagent teams. In Intelligent Robots and Systems, 2007. IROS 2007. IEEE/RSJ International Conference on, pages 64–69. IEEE, 2007.

[22]
L. Matignon, G. J. Laurent, and N. Le FortPiat.
Independent reinforcement learners in cooperative markov games: a
survey regarding coordination problems.
The Knowledge Engineering Review
, 27(01):1–31, 2012.  [23] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. Humanlevel control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
 [24] I. Mordatch and P. Abbeel. Emergence of grounded compositional language in multiagent populations. arXiv preprint arXiv:1703.04908, 2017.
 [25] S. Omidshafiei, J. Pazis, C. Amato, J. P. How, and J. Vian. Deep decentralized multitask multiagent reinforcement learning under partial observability. CoRR, abs/1703.06182, 2017.
 [26] L. Panait and S. Luke. Cooperative multiagent learning: The state of the art. Autonomous Agents and MultiAgent Systems, 11(3):387–434, Nov. 2005.
 [27] P. Peng, Q. Yuan, Y. Wen, Y. Yang, Z. Tang, H. Long, and J. Wang. Multiagent bidirectionallycoordinated nets for learning to play starcraft combat games. CoRR, abs/1703.10069, 2017.
 [28] D. Silver, A. Huang, C. J. Maddison, A. Guez, L. Sifre, G. van den Driessche, J. Schrittwieser, I. Antonoglou, V. Panneershelvam, M. Lanctot, S. Dieleman, D. Grewe, J. Nham, N. Kalchbrenner, I. Sutskever, T. Lillicrap, M. Leach, K. Kavukcuoglu, T. Graepel, and D. Hassabis. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484 – 489, 2016.

[29]
S. Sukhbaatar, R. Fergus, et al.
Learning multiagent communication with backpropagation.
In Advances in Neural Information Processing Systems, pages 2244–2252, 2016.  [30] S. Sukhbaatar, I. Kostrikov, A. Szlam, and R. Fergus. Intrinsic motivation and automatic curricula via asymmetric selfplay. arXiv preprint arXiv:1703.05407, 2017.
 [31] R. S. Sutton and A. G. Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.
 [32] R. S. Sutton, D. A. McAllester, S. P. Singh, and Y. Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in neural information processing systems, pages 1057–1063, 2000.
 [33] A. Tampuu, T. Matiisen, D. Kodelja, I. Kuzovkin, K. Korjus, J. Aru, J. Aru, and R. Vicente. Multiagent cooperation and competition with deep reinforcement learning. PloS one, 12(4):e0172395, 2017.
 [34] M. Tan. Multiagent reinforcement learning: Independent vs. cooperative agents. In Proceedings of the tenth international conference on machine learning, pages 330–337, 1993.
 [35] G. Tesauro. Extending qlearning to general adaptive multiagent systems. In Advances in neural information processing systems, pages 871–878, 2004.
 [36] P. S. Thomas and A. G. Barto. Conjugate markov decision processes. In Proceedings of the 28th International Conference on Machine Learning (ICML11), pages 137–144, 2011.
 [37] R. J. Williams. Simple statistical gradientfollowing algorithms for connectionist reinforcement learning. Machine learning, 8(34):229–256, 1992.
Appendix
MultiAgent Deep Deterministic Policy Gradient Algorithm
For completeness, we provide the MADDPG algorithm below.
Experimental Results
In all of our experiments, we use the Adam optimizer with a learning rate of 0.01 and for updating the target networks. is set to be 0.95. The size of the replay buffer is and we update the network parameters after every 100 samples added to the replay buffer. We use a batch size of 1024 episodes before making an update, except for TRPO where we found a batch size of 50 lead to better performance (allowing it more updates relative to MADDPG). We train with 10 random seeds for environments with stark success/ fail conditions (cooperative communication, physical deception, and covert communication) and 3 random seeds for the other environments.
The details of the experimental results are shown in the following tables.
Agent  Target reach %  Average distance 

MADDPG  84.0%  0.133 
DDPG  32.0%  0.456 
DQN  24.8%  0.754 
ActorCritic  17.2%  2.071 
TRPO  20.6%  1.573 
REINFORCE  13.6%  3.333 
, which indicates the percentage of runs in which the correct policy was learned (consistently reaching the target landmark). Even when the correct behavior is learned, agents occasionally hover slightly outside the target landmark on some episodes, and conversely agents who learn to go to the middle of the landmarks occasionally stumble upon the correct landmark.
Agent  Average dist.  # collisions  Average dist.  # collisions 

MADDPG  1.767  0.209  3.345  1.366 
DDPG  1.858  0.375  3.350  1.585 
Agent  Adversary  # touches (pp1)  # touches (pp2) 

MADDPG  MADDPG  11.0  0.202 
MADDPG  DDPG  16.1  0.405 
DDPG  MADDPG  10.3  0.298 
DDPG  DDPG  9.4  0.321 
Agent  Adversary  AG succ %  ADV succ %  succ %  AG succ %  ADV succ %  succ % 

MADDPG  MADDPG  94.4%  39.2%  55.2%  81.5%  28.3%  53.2% 
MADDPG  DDPG  92.2%  16.4%  75.8%  69.6%  19.8%  49.4% 
DDPG  MADDPG  68.9%  59.0%  9.9%  35.7%  32.1%  3.6% 
DDPG  DDPG  74.7%  38.6%  36.1%  18.4%  35.8%  17.4% 
Alice, Bob  Eve  Bob succ %  Eve succ %  succ % 

MADDPG  MADDPG  96.5%  52.1%  44.4% 
MADDPG  DDPG  96.8%  44.4%  52.4% 
DDPG  MADDPG  65.3%  64.3%  1.0% 
DDPG  DDPG  92.7%  67.6%  25.1% 
, i.e. correctly reconstructing the speaker’s message) in the covert communication environment. The input message is drawn from a set of two 4dimensional onehot vectors.



Variance of Policy Gradient Algorithms in a Simple MultiAgent Setting
To analyze the variance of policy gradient methods in multiagent settings, we consider a simple cooperative scenario with agents and binary actions: . We define the reward to be if all actions are the same , and otherwise. This is a simple scenario with no temporal component: agents must simply learn to either always output or always output at each time step. Despite this, we can show that the probability of taking a gradient step in the correct direction decreases exponentially with the number of agents .
Proposition 1.
Consider agents with binary actions: , where . We assume an uninformed scenario, in which agents are initialized to . Then, if we are estimating the gradient of the cost with policy gradient, we have:
where is the policy gradient estimator from a single sample, and is the true gradient.
Proof.
We can write , and .
The policy gradient estimator (from a single sample) is:
(10) 
For we have:
And the expected reward can be calculated as:
Consider the case where . Then
and
The variance of a single sample of the gradient is then:
What is the probability of taking a step in the right direction? We can look at . We have:
so . Thus, as the number of agents increases, the probability of taking a gradient step in the right direction decreases exponentially. ∎
While this is a somewhat artificial example, it serves to illustrate that there are simple environments that become progressively more difficult (in terms of the probability of taking a gradient step in a direction that increases reward) for policy gradient methods as the number of agents grows. This is particularly true in environments with sparse rewards, such as the one described above. Note that in this example, the policy gradient variance actually decreases as N grows. However, the expectation of the policy gradient decreases as well, and the signal to noise ratio decreases with , corresponding to the decreasing probability of a correct gradient direction. The intuitive reason a centralized critic helps reduce the variance of the gradients is that we remove a source of uncertainty; conditioned only on the agent’s own actions, there is significant variability associated with the actions of other agents, which is largely removed when using these actions as input to the critic.