Log In Sign Up

Monotonic Value Function Factorisation for Deep Multi-Agent Reinforcement Learning

In many real-world settings, a team of agents must coordinate its behaviour while acting in a decentralised fashion. At the same time, it is often possible to train the agents in a centralised fashion where global state information is available and communication constraints are lifted. Learning joint action-values conditioned on extra state information is an attractive way to exploit centralised learning, but the best strategy for then extracting decentralised policies is unclear. Our solution is QMIX, a novel value-based method that can train decentralised policies in a centralised end-to-end fashion. QMIX employs a mixing network that estimates joint action-values as a monotonic combination of per-agent values. We structurally enforce that the joint-action value is monotonic in the per-agent values, through the use of non-negative weights in the mixing network, which guarantees consistency between the centralised and decentralised policies. To evaluate the performance of QMIX, we propose the StarCraft Multi-Agent Challenge (SMAC) as a new benchmark for deep multi-agent reinforcement learning. We evaluate QMIX on a challenging set of SMAC scenarios and show that it significantly outperforms existing multi-agent reinforcement learning methods.


page 3

page 18


QMIX: Monotonic Value Function Factorisation for Deep Multi-Agent Reinforcement Learning

In many real-world settings, a team of agents must coordinate their beha...

Multi-Agent Common Knowledge Reinforcement Learning

In multi-agent reinforcement learning, centralised policies can only be ...

Value Functions Factorization with Latent State Information Sharing in Decentralized Multi-Agent Policy Gradients

Value function factorization via centralized training and decentralized ...

Weighted QMIX: Expanding Monotonic Value Function Factorisation

QMIX is a popular Q-learning algorithm for cooperative MARL in the centr...

DQMIX: A Distributional Perspective on Multi-Agent Reinforcement Learning

In cooperative multi-agent tasks, a team of agents jointly interact with...

Greedy-based Value Representation for Optimal Coordination in Multi-agent Reinforcement Learning

Due to the representation limitation of the joint Q value function, mult...

Multi-agent Reinforcement Learning with Sparse Interactions by Negotiation and Knowledge Transfer

Reinforcement learning has significant applications for multi-agent syst...

1 Introduction

Reinforcement learning (RL) holds considerable promise to help address a variety of cooperative multi-agent problems, such as coordination of robot swarms (Hüttenrauch et al., 2017) and autonomous cars (Cao et al., 2012).

In many such settings, partial observability and/or communication constraints necessitate the learning of decentralised policies, which condition only on the local action-observation history of each agent. Decentralised policies also naturally attenuate the problem that joint action spaces grow exponentially with the number of agents, often rendering the application of traditional single-agent RL methods impractical.

Fortunately, decentralised policies can often be learned in a centralised fashion in a simulated or laboratory setting. This often grants access to additional state information, otherwise hidden from agents, and removes inter-agent communication constraints. The paradigm of centralised training with decentralised execution (Oliehoek et al., 2008; Kraemer and Banerjee, 2016) has recently attracted attention in the RL community (Jorge et al., 2016; Foerster et al., 2018). However, many challenges surrounding how to best exploit centralised training remain open.

One of these challenges is how to represent and use the action-value function that many RL methods learn. On the one hand, properly capturing the effects of the agents’ actions requires a centralised action-value function that conditions on the global state and the joint action. On the other hand, such a function is difficult to learn when there are many agents and, even if it can be learned, offers no obvious way to extract decentralised policies that allow each agent to select only an individual action based on an individual observation.

The simplest option is to forgo a centralised action-value function and let each agent learn an individual action-value function independently, as in independent Q-learning (IQL) (Tan, 1993). However, this approach cannot explicitly represent interactions between the agents and may not converge, as each agent’s learning is confounded by the learning and exploration of others.

At the other extreme, we can learn a fully centralised action-value function and then use it to guide the optimisation of decentralised policies in an actor-critic framework, an approach taken by counterfactual multi-agent (COMA) policy gradients (Foerster et al., 2018), as well as work by Gupta et al. (2017). However, this requires on-policy learning, which can be sample-inefficient, and training the fully centralised critic becomes impractical when there are more than a handful of agents.

In between these two extremes, we can learn a centralised but factored , an approach taken by value decomposition networks (VDN) (Sunehag et al., 2017). By representing as a sum of individual value functions that condition only on individual observations and actions, a decentralised policy arises simply from each agent selecting actions greedily with respect to its . However, VDN severely limits the complexity of centralised action-value functions that can be represented and ignores any extra state information available during training.

In this paper, we propose a new approach called QMIX which, like VDN, lies between the extremes of IQL and COMA, but can represent a much richer class of action-value functions. Key to our method is the insight that the full factorisation of VDN is not necessary to extract decentralised policies. Instead, we only need to ensure that a global performed on yields the same result as a set of individual operations performed on each . To this end, it suffices to enforce a monotonicity constraint on the relationship between and each :


QMIX consists of agent networks representing each , and a mixing network that combines them into , not as a simple sum as in VDN, but in a complex nonlinear way that ensures consistency between the centralised and decentralised policies. At the same time, it enforces the constraint of (1) by restricting the mixing network to have positive weights. We use hypernetworks (Ha et al., 2017) to condition the weights of the mixing network on the state, which is observed only during training. As a result, QMIX can represent complex centralised action-value functions with a factored representation that scales well in the number of agents and allows decentralised policies to be easily extracted via inexpensive individual argmax operations.

To evaluate QMIX, as well as the growing number of other algorithms recently proposed for multi-agent RL (Foerster et al., 2018; Sunehag et al., 2017), we introduce the StarCraft Multi-Agent Challenge (SMAC)111Code is available at In single-agent RL, standard environments such as the Arcade Learning Environment (Bellemare et al., 2013) and MuJoCo (Plappert et al., 2018) have facilitated rapid progress. While some multi-agent testbeds have emerged, such as Poker (Heinrich and Silver, 2016), Pong (Tampuu et al., 2017), Keepaway Soccer (Stone et al., 2005), or simple gridworld-like environments (Lowe et al., 2017; Leibo et al., 2017; Yang et al., 2018; Zheng et al., 2017), there are currently no challenging standard testbeds for centralised training with decentralised execution with the exception of the recently introduced Hanabi Challenge (Bard et al., 2020) which focusses on a setting with less than 5 agents.

(a) 3 Stalkers vs 5 Zealots
(b) 2 Collosi vs 64 Zerglings
Figure 1: Decentralised unit micromanagement in StarCraft II, where each learning agent controls an individual unit. The goal is to coordinate behaviour across agents to defeat all enemy units.

SMAC fills this gap. It is built on the popular real-time strategy game StarCraft II and makes use of the SC2LE environment (Vinyals et al., 2017). Instead of tackling the full game of StarCraft with centralised control, it focuses on decentralised micromanagement challenges (Figure 1). In these challenges, each of our units is controlled by an independent, learning agent that has to act based only on local observations, while the opponent’s units are controlled by the hand-coded built-in StarCraft II AI. SMAC offers a diverse set of scenarios that challenge algorithms to handle high-dimensional inputs and partial observability, and to learn coordinated behaviour even when restricted to fully decentralised execution. In contrast to the diverse set of scenarios included in SMAC, the Hanabi Challenge focusses on a single task involving between 2-5 agents designed to test agents’ ability to reason about the actions of the other agents (an ability in humans referred to as theory of mind (Rabinowitz et al., 2018)).

To further facilitate research in this field, we also open-source PyMARL, a learning framework that can serve as a starting point for other researchers and includes implementations of several key multi-agent RL algorithms. PyMARL is modular, extensible, built on PyTorch, and serves as a template for dealing with some of the unique challenges of deep multi-agent RL in practice. We also offer a set of guidelines for best practices in evaluations using our benchmark, including the reporting of standardised performance metrics, sample efficiency, and computational requirements (see Section 


Our experiments on SMAC show that QMIX outperforms IQL, VDN, and COMA, both in terms of absolute performance and learning speed. In particular, our method shows considerable performance gains on the harder tasks in SMAC, and tasks with heterogeneous agents. Moreover, our analysis and ablations show both the necessity of conditioning on the state information and a flexible multi-layer network for mixing of agent -values in order to achieve consistent performance across tasks.

Since its introduction by Rashid et al. (2018), QMIX has become an important value-based algorithm in discrete action environments. It has inspired a number of extensions and follow-up work (Section 2.4) and is a prominent point of comparison in any work that utilises SMAC (Section 2.5). Recently it is becoming increasingly common (and arguably necessary) to evaluate deep multi-agent RL algorithms on non-gridworld environments. This has been driven in part by the introduction of PyMARL and SMAC, which provide an open-source codebase and a standardised testbed for evaluating and comparing deep multi-agent RL algorithms.222 This work was originally published as a conference paper (Rashid et al., 2018). The main additions in this article are: Introducing SMAC, a benchmark for the cooperative multi-agent RL setting of centralised training and decentralised execution (Section 7). Releasing PyMARL, a framework for running and developing multi-agent RL algorithms (Section 8). Experimental results comparing IQL, VDN, COMA, and QTRAN on the SMAC benchmark (Section 9). Further analysis and ablation experiments to investigate why QMIX outperforms VDN (Sections 6 and 10). Comprehensive literature review of classical as well as novel cooperative multi-agent RL approaches (Section 2).

2 Related Work

Recent work in multi-agent RL has started moving from tabular methods (Yang and Gu, 2004; Busoniu et al., 2008)

to deep learning methods that can tackle high-dimensional state and action spaces

(Tampuu et al., 2017; Foerster et al., 2018; Peng et al., 2017; de Witt et al., 2018). In this paper, we focus on the fully-cooperative setting in which all agents must maximise a joint reward signal in the paradigm of centralised training and decentralised execution.

2.1 Independent Learners

A natural approach to producing decentraliseable agents in a multi-agent system is to directly learn decentralised value functions or policies. Independent Q-learning (Tan, 1993) trains independent action-value functions for each agent using -learning (Watkins, 1989). Tampuu et al. (2017)

extend this approach to deep neural networks using DQN

(Mnih et al., 2015). While trivially achieving decentralisation, these approaches are prone to instability arising from the non-stationarity of the environment induced by simultaneously learning and exploring agents. Foerster et al. (2017) addresses the issue of non-stationarity when using an experience replay with independent learners to some extent. Lauer and Riedmiller (2000) ignore updates which decrease -value estimates in order to not prematurely underestimate an action’s -value due to the exploratory actions of other agents. In a tabular setting, they prove this converges to the optimal policy in deterministic environments, provided there is a unique optimal joint-action. Matignon et al. (2007) introduce Hysteretic -learning which instead uses a smaller learning rate for decreasing -value estimates, which is slightly more robust to stochasticity and the presence of multiple optimal joint actions. Omidshafiei et al. (2017) utilises Hysteretic -learning in a multi-task deep RL setting. Panait et al. (2008) introduce Leniency which ignores updates that decrease

-value estimates with a probability that is decreasing during training.

Wei and Luke (2016) show that Leniency outperforms Hysteretic -learning in cooperative stochastic games, and Palmer et al. (2018) extend Leniency to the deep RL setting and show benefits over Hysteretic and fully Independent -learners on deterministic and stochastic gridworlds with two agents. Palmer et al. (2019) maintain a learned interval whose lower bound is approximately the minimum cumulative reward received when all agents are coordinating. They use this interval when decreasing -value estimates to distinguish between miscoordination between the agents and the stochasticity of the environment, which Hysteretic and Lenient learners do not distinguish between. Lu and Amato (2019) utilise Distributional RL (Bellemare et al., 2017) in combination with Hysteretic

-learning in order to also distinguish between miscoordination and stochasticity, and argue their approach is more stable and robust to hyperparameters than the above methods. All of these approaches do not utilise extra state information available during a centralised training regime, nor do they attempt to learn joint action-value functions.

2.2 Centralised Execution

In settings where decentralised execution is not mandatory, the centralised learning of joint action-value function naturally handles the coordination problems and avoids the non-stationarity problem. Nonetheless, a centralised action-value function is impractical to scale since the joint action space grows exponentially in the number of agents. Classical approaches to scalable centralised learning include coordination graphs (Guestrin et al., 2002), which exploit conditional independencies between agents by decomposing a global reward function into a sum of agent-local terms. This can significantly reduce the computation required in order to find the maximum joint action (depending on the exact structure of the coordination graph supplied) through message-passing algorithms. However, specifying an appropriate coordination graph (i.e. not fully-connected) can require significant domain knowledge. Sparse cooperative Q-learning (Kok and Vlassis, 2006) is a tabular -learning algorithm that learns to coordinate the actions of a group of cooperative agents only in the states in which such coordination is necessary, encoding those dependencies in a coordination graph. Both methods require the dependencies between agents to be pre-supplied, whereas we do not require such prior knowledge. Castellini et al. (2019) investigate the representational capacity of coordination graphs in a deep RL setting using one-step matrix games. Böhmer et al. (2019) also extend coordination graphs to the deep RL setting, making use of parameter sharing and limiting the graphs to contain only pairwise edges, in order to consider more complex scenarios. Chen et al. (2018) similarly factor the joint -function into pairwise interaction terms, performing maximisation using coordinate ascent instead of message-passing. QMIX (and VDN) correspond to the case of a degenerate fully disconnected coordination graph, thus enabling fully decentralised execution.

DIAL (Foerster et al., 2016)

utilises an end-to-end differentiable architecture that allows for a learned inter-agent communication to emerge via backpropagation. CommNet

(Sukhbaatar et al., 2016) use a centralised network architecture to exchange information between agents. BicNet (Peng et al., 2017) utilise bidirectional RNNs for inter-agent communication in an actor-critic setting and additionally requires estimating individual agent rewards. MAGNet (Malysheva et al., 2018) allow agents to centrally learn a shared graph structure that encodes the relevance of individual environment entities to each agent. Based on this graph, agents can communicate and coordinate their actions during centralised execution. Zhao and Ma (2019) show that the performance of decentralised policies can be improved upon through a centralised communication scheme that uses a central information-filtering neural network in between timesteps. Clustered Deep Q-Networks (CDQN) (Pageaud et al., 2019) use a hierarchical approach in order to scale learning to more agents and larger joint action spaces. Low-level agents are clustered into groups, each of which is managed by a higher-level agent within a centralised execution setting. All low-level agents within a cluster execute the same action selected by a vote, which alleviates some of the non-stationarity of the independent learning setting. In contrast to these approaches, QMIX does not require any form of inter-agent communication during decentralised execution.

2.3 Centralised Training and Decentralised Execution

A number of methods have developed hybrid approaches that exploit the centralised training opportunity for training fully decentralised policies. Gupta et al. (2017) present a centralised actor-critic algorithm with per-agent critics, which scales easily with the number of agents but mitigates the advantages of centralisation. Similarly, Lowe et al. (2017) present MADDPG, which learns a centralised critic for each agent and apply this to competitive games with continuous action spaces. COMA (Foerster et al., 2018) instead uses a single centralised critic to train decentralised actors in the fully-cooperative setting, estimating a counterfactual advantage function for each agent in order to address multi-agent credit assignment. Iqbal and Sha (2018) devise an actor-critic algorithm with per-agent critics that share an attention mechanism in order to improve scalability compared to a single centralised critic. Their approach allows for the agents to have differing action spaces as well allowing for individual rewards. The authors do not compare against QMIX and do not evaluate on environments of similar complexity as StarCraft. de Witt et al. (2018) construct a multi-agent actor-critic algorithm with a hierarchical actor policy that is able to use common knowledge between agents for coordination. Learning Individual Intrinsic Reward (LIIR) (Du et al., 2019) learns an intrinsic reward function for each agent to supplement the team reward. The intrinsic reward function is trained such that it maximises the team reward function. As a bi-level optimization process, LIIR is significantly less computationally efficient than QMIX and has not been demonstrated to scale to large numbers of agents. These approaches are all actor-critic variants which use the policy-gradient theorem, and thus are prone to get stuck sub-optimal local minima. Additionally, all but MADDPG are on-policy algorithms which can have poor sample efficiency compared to off-policy algorithms such as QMIX.

Lin et al. (2019) train a centralised action-value function

which has access to observations of all agent. They then train the decentralised agents via supervised learning to mimic the actions of the centralised policy. Distilling a centralised policy into decentralised agent policies can be problematic since the centralised policy conditions on more information than any of the agents’ policies. QMIX instead learns a factored joint

-function that can be easily decentralised due to its architecture. Sunehag et al. (2017) propose value decomposition networks (VDN), which allow for centralised value function learning with decentralised execution. Their algorithm decomposes a central action-value function into a sum of individual agent terms. VDN does not make use of additional state information during training and can represent only a limited class of centralised action-value functions. Son et al. (2019) introduce QTRAN which learns a centralised, unrestricted, joint -function as well as a VDN-factored joint -function that is decentralisable. Since the unrestricted -value cannot be maximised efficiently, the VDN-factored is used to produce the (approximate) maximum joint-action. They show that solving a linear optimisation problem involving all joint actions, in which the VDN-factored -value matches the unrestricted -value for the approximated maximum joint action and over-estimates for every other action, results in decentralisable policies with the correct argmax. This allows QTRAN to represent a much larger class of joint -function than QMIX, as well as produce decentralisable policies for them. However, exactly solving the linear optimisation problem is prohibitively expensive. Thus, the authors instead optimise a soft approximation using

penalties via stochastic gradient descent. In practice, optimising this loss is difficult which results in poor performance for QTRAN on complex environments such as SMAC.

2.4 Extensions of QMIX

Mahajan et al. (2019) show that the representational constraints of QMIX can prohibit it from learning an optimal policy. Importantly, they show that this is exacerbated by increased -greedy exploration. They introduce MAVEN, which conditions QMIX agents on a shared latent space whose value is chosen at the beginning of an episode by a hierarchical policy. Note that this requires access to the initial state and communication at the first timestep. A mutual information loss is added to encourage diversity of trajectories across the shared latent space, which allows for relatively-greedy agents (once conditioned on the latent variable) to still achieve committed exploration during training similar to Bootstrapped DQN (Osband et al., 2016). This results in significant performance gains on some scenarios in SMAC (Samvelyan et al., 2019).

Action Semantics Networks (ASN) (Wang et al., 2019b) extends QMIX with a novel agent network architecture that separates each agent’s -value estimation of actions that influence other agents from those actions that do not. The -values for actions which influence another agent are computed using that agent’s observation. Since it uses the observations of other agents when computing each agent’s -values, ASN is not decentralisable like QMIX. Additionally, it requires intimate a priori knowledge about an environment’s action semantics.

Wang et al. (2019a) extend QMIX to a setting which allows for communication between agents. Their approach allows agents to condition their

-values on messages from other agents, which take the form of a real-valued vector. An entropy loss and a mutual information loss incentivise the learning of succinct and expressive messages.

Zhang et al. (2019) also allow for each agent’s

-values to condition on vector-valued messages from other agents. However, they only utilise the messages from other agents if their gap between the best and second-best action is small enough (interpreted as uncertainty in the best choice of action). Additionally, they minimise the variance of the messages across actions to limit noisy or uninformative messages.

SMIX() (Yao et al., 2019) replaces the 1-step -learning target of QMIX with a SARSA() target. They incorrectly claim that the -learning update rule is responsible for the representational limitations of QMIX, instead of the non-negative weights in the mixing network which enforces monotonicity. They also incorrectly claim that their method can represent a larger class of joint action-value functions than QMIX. Since they also use non-negative weights in their mixing network, SMIX() can represent exactly the same class of value functions as QMIX.

Liu et al. (2019)

investigate transfer learning algorithms in a multi-agent setting using QMIX as a base.

Yang et al. (2019) use DIAYN (Eysenbach et al., 2018) to learn lower-level skills that a higher level QMIX agent uses. Fu et al. (2019) extend QMIX to allow for action spaces consisting of both discrete and continuous actions.

The applicability of QMIX in real-world application domains has also been considered such as robot swarm coordination (Hüttenrauch et al., 2018) and stratospheric geoengineering (de Witt and Hornigold, 2019).

2.5 PyMARL and SMAC

A number of papers have established unit micromanagement in StarCraft as a benchmark for deep multi-agent RL. Usunier et al. (2017) present an algorithm using a centralised greedy MDP and first-order optimisation which they evaluate on Starcraft: BroodWar (Synnaeve et al., 2016). Peng et al. (2017) also evaluate their methods on StarCraft. However, neither requires decentralised execution. Similar to our setup in SMAC is the work of Foerster et al. (2017), who evaluate replay stabilisation methods for IQL on combat scenarios with up to five agents. Foerster et al. (2018) also uses this setting.

In this paper, we construct unit micromanagement tasks using the StarCraft II Learning Environment (SC2LE) (Vinyals et al., 2017) as opposed to StarCraft, since it is actively supported by the game developers and offers a more stable testing environment. The full game of StarCraft II has already been used as an RL environment (Vinyals et al., 2017), and DeepMind’s AlphaStar (Vinyals et al., 2019) has recently shown an impressive level of play on a StarCraft II matchup using a centralised controller. By contrast, SMAC introduces strict decentralisation and local partial observability to turn the StarCraft II game engine into a new set of decentralised cooperative multi-agent problems.

Since their introduction, SMAC and PyMARL have been used by a number of papers to evaluate and compare multi-agent RL methods (de Witt et al., 2018; Wang et al., 2019c; Du et al., 2019; Wang et al., 2019a; Zhang et al., 2019; Mahajan et al., 2019; Yao et al., 2019; Böhmer et al., 2019; Wang et al., 2019b).

2.6 Hypernetworks and Monotonic Networks

QMIX relies on a neural network to transform the centralised state into the weights of another neural network, in a manner reminiscent of hypernetworks (Ha et al., 2017). This second neural network is constrained to be monotonic with respect to its inputs by keeping its weights positive. Dugas et al. (2009) also investigate such functional restrictions for neural networks.

3 Background

A fully cooperative multi-agent sequential decision-making task can be described as a

decentralised partially observable Markov decision process

(Dec-POMDP) (Oliehoek and Amato, 2016) consisting of a tuple . describes the true state of the environment. At each time step, each agent chooses an action , forming a joint action . This causes a transition on the environment according to the state transition function . All agents share the same reward function and is a discount factor.

We consider a partially observable scenario in which each agent draws individual observations according to observation function . Each agent has an action-observation history , on which it conditions a stochastic policy . The joint policy has a joint action-value function: , where is the discounted return.

Although training is centralised, execution is decentralised, i.e., the learning algorithm has access to all local action-observation histories and global state , but each agent’s learnt policy can condition only on its own action-observation history .

3.1 Deep -Learning

Deep -learning represents the action-value function with a deep neural network parameterised by . Deep Q-networks (DQNs) (Mnih et al., 2015) use a replay memory to store the transition tuple , where the state is observed after taking the action in state and receiving reward . is learnt by sampling batches of transitions from the replay memory and minimising the squared TD error:


where . are the parameters of a target network that are periodically copied from and kept constant for a number of iterations.

3.2 Deep Recurrent -Learning

In partially observable settings, agents can benefit from conditioning on their entire action-observation history. Hausknecht and Stone (2015) propose deep recurrent Q-networks

(DRQN) that make use of recurrent neural networks. Typically, gated architectures such as LSTM

(Hochreiter and Schmidhuber, 1997) or GRU (Chung et al., 2014) are used to facilitate learning over longer timescales.

3.3 Independent -Learning

Perhaps the most commonly applied method in multi-agent learning is independent Q-learning (IQL) (Tan, 1993), which decomposes a multi-agent problem into a collection of simultaneous single-agent problems that share the same environment. This approach does not address the non-stationarity introduced due to the changing policies of the learning agents, and thus, unlike -learning, has no convergence guarantees even in the limit of infinite exploration. In practice, nevertheless, IQL commonly serves as a surprisingly strong baseline even in mixed and competitive games (Tampuu et al., 2017; Leibo et al., 2017).

3.4 Value Decomposition Networks

By contrast, value decomposition networks (VDNs) (Sunehag et al., 2017) aim to learn a joint action-value function , where is a joint action-observation history and is a joint action. It represents as a sum of individual value functions , one for each agent , that condition only on individual action-observation histories:


Strictly speaking, each is a utility function (Guestrin et al., 2002) and not a value function since by itself it does not estimate an expected return. However, for terminological simplicity we refer to both and as value functions.

The loss function for VDN is equivalent to (

2), where is replaced by . An advantage of this representation is that a decentralised policy arises simply from each agent performing greedy action selection with respect to its .

4 Qmix

In this section, we propose a new approach called QMIX which, like VDN, lies between the extremes of IQL and centralised -learning. However, QMIX can represent a much richer class of action-value functions than VDN.

Key to our method is the insight that the full factorisation of VDN is not necessary in order to extract decentralised policies that are fully consistent with their centralised counterpart. As long as the environment is not adversarial, there exists a deterministic optimal policy conditioned on the full action-observation history. Hence, we only need to establish consistency between the deterministic greedy decentralised policies and the deterministic greedy centralised policy based on the optimal joint action-value function. When the greedy decentralised policies are determined by an over the , consistency holds if a global performed on yields the same result as a set of individual operations performed on each :


This allows each agent to participate in a decentralised execution solely by choosing greedy actions with respect to its . As a side effect, if (4) is satisfied, then taking the of , required by off-policy learning updates, is trivially tractable without an exhaustive evaluation of for the exponentially many joint actions.

VDN’s representation is sufficient to satisfy (4). However, QMIX is based on the observation that this representation can be generalised to the larger family of monotonic functions that also satisfy (4). Monotonicity in this context is defined as a constraint on the relationship between and each :


which is sufficient to satisfy (4).

Figure 2: The discrete per-agent action-value scores are fed into the monotonic function . The maximum for each agent is shown in blue, which corresponds to the maximum also shown in blue. The constraint (4) is satisfied due to the monotonicity of .

Figure 2 illustrates the relationship between and individual functions, and how monotonicity leads to a decentralisable in an example with two agents with three possible actions. Each agent produces scores for each discrete action that it can take (columns with the local in blue). These are the inputs to a continuous monotonic mixing function , the output of which is represented by the monotonically increasing heatmap. The intersections of the blue lines indicate the estimated for each of the discrete joint actions. Due to the monotonicity of , these joint-action value estimates maintain the ordering corresponding to each agent’s , for that agent’s actions when the other agents’ actions remain fixed. The result is that the global greedy joint action of , indicated by the blue dot, corresponds to the set of decentralised greedy actions.

We now describe how QMIX enforces (5) in practice, by representing using an architecture consisting of agent networks, a mixing network, and a set of hypernetworks (Ha et al., 2017). Figure 3 illustrates the overall setup.

             (a) (b) (c)           

Figure 3: (a) Mixing network structure. In red are the hypernetworks that produce the weights and biases for mixing network layers shown in blue. (b) The overall QMIX architecture. (c) Agent network structure. Best viewed in colour.

For each agent , there is one agent network that represents its individual value function . We represent agent networks as DRQNs that receive the current individual observation and the last action as input at each time step, as shown in Figure 3c.

The mixing network is a feed-forward neural network that takes the agent network outputs as input and mixes them monotonically, producing the values of

, as shown in Figure 3a. To enforce the monotonicity constraint of (5), the weights (but not the biases) of the mixing network are restricted to be non-negative. This allows the mixing network to approximate any monotonic function arbitrarily closely in the limit of infinite width (Dugas et al., 2009).

The weights of each layer of the mixing network are produced by separate hypernetworks. Each hypernetwork takes the state

as input and generates the weights of one layer of the mixing network. Each hypernetwork consists of two fully-connected layers with a ReLU nonlinearity, followed by an absolute activation function, to ensure that the mixing network weights are non-negative. The output of the hypernetwork is then a vector, which is reshaped into a matrix of appropriate size. The biases are produced in the same manner but are not restricted to being non-negative. The first bias is produced by a hypernetwork with a single linear layer, and the final bias is produced by a two-layer hypernetwork with a ReLU nonlinearity. Figure

3a illustrates the mixing network and the hypernetworks.

The state is used by the hypernetworks rather than being passed directly into the mixing network because is allowed to depend on the extra state information in non-monotonic ways. Thus, it would be overly constraining to pass some function of through the monotonic network alongside the per-agent values. Instead, the use of hypernetworks makes it possible to condition the weights of the monotonic network on in an arbitrary way, thus integrating the full state into the joint action-value estimates as flexibly as possible. The choice of nonlinearity for the mixing network is also an important consideration due to its interaction with the non-negative weights. A ReLU is not a good choice since a negative input to the mixing network is likely to remain negative (depending on the biases), which would then be zeroed out by the ReLU leading to no gradients for all agent networks. It is for this reason that we use an ELU.

QMIX is trained end-to-end to minimise the following loss:


where is the batch size of transitions sampled from the replay buffer, the DQN target is given by , and are the parameters of a target network as in DQN. (6) is analogous to the standard DQN loss of (2). Since (4) holds, we can perform the maximisation of in time linear in the number of agents (as opposed to scaling exponentially in the worst case).

  Initialise , the parameters of mixing network, agent networks and hypernetwork.
  Set the learning rate and replay buffer
  while  do
     while  and  do
        for each agent  do
        end for
        Get reward and next state
     end while
     if  then
        b random batch of episodes from
        for each timestep in each episode in batch  do
           Calculate target using Mixing-network with
        end for
         // Eq (6)
     end if
     if update-interval steps have passed then
     end if
  end while
Algorithm 1 QMIX

In Algorithm 1 we outline the pseudocode for the particular implementation of QMIX we use for all of our experiments. The choice to gather rollouts from an entire episode before executing a single gradient descent step, as well as using per-agent -greedy action selection, is not a requirement for QMIX.

4.1 Representational Complexity

The value function class representable with QMIX includes any value function that can be factored into a nonlinear monotonic combination of the agents’ individual value functions in the fully observable setting.

This follows since the mixing network is a universal function approximator of monotonic functions (Dugas et al., 2009), and hence can represent any value function that factors into a nonlinear monotonic combination of the agent’s individual value functions. Additionally, we require that the agent’s individual value functions order the values of the actions appropriately. By this we mean that is such that , i.e., they can represent a function that respects the ordering of the agent’s actions in the joint-action value function. Since the agents’ networks are universal function approximators (Pinkus, 1999), they can represent such a . Hence QMIX is able to represent any value function that factors into a nonlinear monotonic combination of the agent’s individual value functions.

In a Dec-POMDP, QMIX cannot necessarily represent the true optimal -function. This is because each agent’s observations are no longer the full state, and thus they might not be able to distinguish the true state given their local observations. If the agent’s value function ordering is then wrong, i.e., when , then the mixing network would be unable to correctly represent given the monotonicity constraints.

QMIX thus expands upon the linear monotonic value functions that are representable by VDN. Table 1a gives an example of a monotonic value function for the simple case of a two-agent matrix game. Note that VDN is unable to represent this simple monotonic value function.



0 1
1 8


2 1
1 8
Table 1: (a) An example of a monotonic payoff matrix, (b) a non-monotonic payoff matrix.

However, the constraint in (5) prevents QMIX from representing value functions that do not factorise in such a manner. A simple example of such a value function for a two-agent matrix game is given in Table 1b. Intuitively, any value function for which an agent’s best action depends on the actions of the other agents at the same time step will not factorise appropriately, and hence cannot be perfectly represented by QMIX. However, even though QMIX cannot perfectly represent such value functions, its increased representational capacity allows it to learn -value estimates that are more accurate for computing the target values to regress onto during -learning targets (bootstrapping). In particular, we show in Section 5 that the increased representational capacity allows for QMIX to learn the optimal policy in an environment with no per-timestep coordination, compared to VDN which still fails to learns the optimal policy. In Section 6 we show that QMIX learns significantly more accurate maxima over in randomly generated matrix games, demonstrating that it learns better -value estimates for bootstrapping. Finally, we show in Section 9 that QMIX significantly outperforms VDN on the challenging SMAC benchmark.

5 Two-Step Game

To illustrate the effects of representational complexity of VDN and QMIX, we devise a simple two-step cooperative matrix game for two agents.

At the first step, Agent chooses which of the two matrix games to play in the next timestep. For the first time step, the actions of Agent have no effect. In the second step, both agents choose an action and receive a global reward according to the payoff matrices depicted in Table 2.

We train VDN and QMIX on this task for episodes and examine the final learned value functions in the limit of full exploration (). Full exploration ensures that each method is guaranteed to eventually explore all available game states, such that the representational capacity of the state-action value function approximation remains the only limitation. The full details of the architecture and hyperparameters used, as well as additional results are provided in Appendix A.



7 7
7 7
State A


0 1
1 8
State B
Table 2: Payoff matrices of the two-step game after the Agent 1 chose the first action. Action A takes the agents to State A and action B takes them to State B.

(a) State 6.94 6.94 6.35 6.36   State A 6.99 7.02 6.99 7.02   State B -1.87 2.31 2.33 6.51

(b) 6.93 6.93 7.92 7.92   7.00 7.00 7.00 7.00   0.00 1.00 1.00 8.00

Table 3: on the two-step game for (a) VDN and (b) QMIX.

Table 3, which shows the learned values for , demonstrates that QMIX’s higher representational capacity allows it to accurately represent the joint-action value function whereas VDN cannot. This directly translates into VDN learning the suboptimal strategy of selecting Action A at the first step and receiving a reward of 7, whereas QMIX recovers the optimal strategy from its learnt joint-action values and receives a reward of 8.

The simple example presented in this section demonstrates the importance of accurate -value estimates, especially for the purpose of bootstrapping. In Section 6 we provide further evidence that QMIX’s increased representational capacity allows it to learn more accurate -value, that directly lead to more accurate bootstrapped estimates.

6 Random Matrix Games

To demonstrate that QMIX learns more accurate -values than VDN for the purpose of bootstrapping, we compare the learnt values of on randomly generated matrix games. Single-step matrix games allow us to compare the learnt maximum -values across both methods in isolation. We focus on because it is the only learnt quantity involved in the bootstrapping for 1-step -learning.

The maximum return for each matrix is , and all other values are drawn uniformly from . Each individual seed has different values for the payoff matrix, but within each run they remain fixed. We set to ensure all actions are sampled and trained on equally.

Figure 4: The median for agents with

actions across 10 runs for VDN and QMIX. 25%-75% quartile is shown shaded. The dashed line at 10 indicates the correct value.

Figure 4 shows the results for a varying number of agents and actions. We can see that QMIX learns signifcantly more accurate maxima than VDN due to its larger representational capacity.

7 The StarCraft Multi-Agent Challenge

In this section, we describe the StarCraft Multi-Agent Challenge (SMAC) to which we apply QMIX and a number of other methods. SMAC is based on the popular real-time strategy (RTS) game StarCraft II. In a regular full game of StarCraft II, one or more humans compete against each other or against a built-in game AI to gather resources, construct buildings, and build armies of units to defeat their opponents.

Akin to most RTSs, StarCraft has two main gameplay components: macromanagement and micromanagement. Macromanagement refers to high-level strategic considerations, such as economy and resource management. Micromanagement (micro), on the other hand, refers to fine-grained control of individual units.

StarCraft has been used as a research platform for AI, and more recently, RL. Typically, the game is framed as a competitive problem: an agent takes the role of a human player, making macromanagement decisions and performing micromanagement as a puppeteer that issues orders to individual units from a centralised controller.

In order to build a rich multi-agent testbed, we instead focus solely on micromanagement. Micro is a vital aspect of StarCraft gameplay with a high skill ceiling, and is practiced in isolation by amateur and professional players. For SMAC, we leverage the natural multi-agent structure of micromanagement by proposing a modified version of the problem designed specifically for decentralised control. In particular, we require that each unit be controlled by an independent agent that conditions only on local observations restricted to a limited field of view centred on that unit (see Figure 5). Groups of these agents must be trained to solve challenging combat scenarios, battling an opposing army under the centralised control of the game’s built-in scripted AI.

Figure 5: The cyan and red circles respectively border the sight and shooting range of the agent.

Proper micro of units during battles maximises the damage dealt to enemy units while minimising damage received, and requires a range of skills. For example, one important technique is focus fire, i.e., ordering units to jointly attack and kill enemy units one after another. When focusing fire, it is important to avoid overkill: inflicting more damage to units than is necessary to kill them. Other common micro techniques include: assembling units into formations based on their armour types, making enemy units give chase while maintaining enough distance so that little or no damage is incurred (kiting, Figure 1a), coordinating the positioning of units to attack from different directions or taking advantage of the terrain to defeat the enemy.

(a) MMM2
(b) corridor
Figure 6: Screenshots of two SMAC scenarios.

SMAC thus provides a convenient environment for evaluating the effectiveness of MARL algorithms. The simulated StarCraft II environment and carefully designed scenarios require learning rich cooperative behaviours under partial observability, which is a challenging task. The simulated environment also provides an additional state information during training, such as information on all the units on the entire map. This is crucial for facilitating algorithms to take full advantage of the centralised training regime and assessing all aspects of MARL methods.

SMAC is a qualitatively challenging environment that involves elements of partial observability, challenging dynamics, and high-dimensional observation spaces. We hope that it will become a standard benchmark for measuring the progress and a grand challenge for pushing the boundaries of MARL.

7.1 Scenarios

SMAC consists of a set of StarCraft II micro scenarios which aim to evaluate how well independent agents are able to learn coordination to solve complex tasks. These scenarios are carefully designed to necessitate the learning of one or more micro techniques to defeat the enemy. Each scenario is a confrontation between two armies of units. The initial position, number, and type of units in each army varies from scenario to scenario, as does the presence or absence of elevated or impassable terrain. Figures 1 and 6 include screenshots of several SMAC micro scenarios.

The first army is controlled by the learned allied agents. The second army consists of enemy units controlled by the built-in game AI, which uses carefully handcrafted non-learned heuristics. At the beginning of each episode, the game AI instructs its units to attack the allied agents using its scripted strategies. An episode ends when all units of either army have died or when a pre-specified time limit is reached (in which case the game is counted as a defeat for the allied agents). The goal is to maximise the win rate, i.e., the ratio of games won to games played.

The complete list of challenges is presented in Table 4. More specifics on the SMAC scenarios and environment settings can be found in Appendices C.1 and C.2 respectively.

Name Ally Units Enemy Units
2s3z 2 Stalkers & 3 Zealots 2 Stalkers & 3 Zealots
3s5z 3 Stalkers & 5 Zealots 3 Stalkers & 5 Zealots
1c3s5z 1 Colossus, 3 Stalkers & 5 Zealots 1 Colossus, 3 Stalkers & 5 Zealots
5m_vs_6m 5 Marines 6 Marines
10m_vs_11m 10 Marines 11 Marines
27m_vs_30m 27 Marines 30 Marines
3s5z_vs_3s6z 3 Stalkers & 5 Zealots 3 Stalkers & 6 Zealots
MMM2 1 Medivac, 2 Marauders & 7 Marines 1 Medivac, 3 Marauders & 8 Marines
2s_vs_1sc 2 Stalkers 1 Spine Crawler
3s_vs_5z 3 Stalkers 5 Zealots
6h_vs_8z 6 Hydralisks 8 Zealots
bane_vs_bane 20 Zerglings & 4 Banelings 20 Zerglings & 4 Banelings
2c_vs_64zg 2 Colossi 64 Zerglings
corridor 6 Zealots 24 Zerglings
Table 4: SMAC challenges. Note that list of SMAC scenarios has been updated from the earlier version. All scenarios, however, are still available in the repository.

7.2 State and Observations

At each timestep, agents receive local observations drawn within their field of view. This encompasses information about the map within a circular area around each unit and with a radius equal to the sight range (Figure 5). The sight range makes the environment partially observable from the standpoint of each agent. Agents can only observe other agents if they are both alive and located within the sight range. Hence, there is no way for agents to distinguish between teammates that are far away from those that are dead.

The feature vector observed by each agent contains the following attributes for both allied and enemy units within the sight range: distance, relative x, relative y, health, shield, and unit_type. Shields serve as an additional source of protection that needs to be removed before any damage can be done to the health of units. All Protos units have shields, which can regenerate if no new damage is dealt. In addition, agents have access to the last actions of allied units that are in the field of view. Lastly, agents can observe the terrain features surrounding them, in particular, the values of eight points at a fixed radius indicating height and walkability.

The global state, which is only available to agents during centralised training, contains information about all units on the map. Specifically, the state vector includes the coordinates of all agents relative to the centre of the map, together with unit features present in the observations. Additionally, the state stores the energy of Medivacs and cooldown of the rest of the allied units, which represents the minimum delay between attacks. Finally, the last actions of all agents are attached to the central state.

All features, both in the state as well as in the observations of individual agents, are normalised by their maximum values. The sight range is set to nine for all agents.

7.3 Action Space

The discrete set of actions that agents are allowed to take consists of move[direction]333Four directions: north, south, east, or west., attack[enemy_id], stop and no-op.444Dead agents can only take no-op action while live agents cannot. As healer units, Medivacs must use heal[agent_id] actions instead of attack[enemy_id]. The maximum number of actions an agent can take ranges between 7 and 70, depending on the scenario.

To ensure decentralisation of the task, agents can use the attack[enemy_id] action only on enemies in their shooting range (Figure 5). This additionally constrains the ability of the units to use the built-in attack-move macro-actions on enemies that are far away. We set the shooting range to six for all agents. Having a larger sight range than a shooting range forces agents to use move commands before starting to fire.

7.4 Rewards

The overall goal is to maximise the win rate for each battle scenario. The default setting is to use the shaped reward, which produces a reward based on the hit-point damage dealt and enemy units killed, together with a special bonus for winning the battle. The exact values and scales for each of these events can be configured using a range of flags. To produce fair comparisions we encourage using this default reward function for all scenarios. We also provide another sparse reward option, in which the reward is +1 for winning and -1 for losing an episode.

7.5 Evaluation Methodology

To ensure the fairness of the challenge and comparability of results, performance should be evaluated under standardised conditions. One should not undertake any changes to the environment used for evaluating the policies. This includes the observation and state spaces, action space, the game mechanics, and settings of the environment (e.g., frame-skipping rate). One should not modify the StarCraft II map files in any way or change the difficulty of the game AI. Episode limits of each scenario should also remain unchanged.

SMAC restricts the execution of the trained models to be decentralised, i.e., during testing each agent must base its policy solely on its own action-observation history and cannot use the global state or the observations of other agents. It is, however, acceptable to train the decentralised policies in centralised fashion. Specifically, agents can exchange individual observations, model parameters and gradients during training as well as make use of the global state.

7.6 Evaluation Metrics

Our main evaluation metric is the mean win percentage of evaluation episodes as a function of environment steps observed, over the course of training. Such progress can be estimated by periodically running a fixed number of evaluation episodes (in practice, 32) with any exploratory behaviours disabled. Each experiment is repeated using a number of independent training runs and the resulting plots include the median performance as well as the 25-75% percentiles. We use five independent runs for this purpose in order to strike a balance between statistical significance and the computational requirements. We recommend using the median instead of the mean in order to avoid the effect of any outliers. We report the number of independent runs, as well as environment steps used in training.

We also include the computational resources used, as well as the wall clock time for running each experiment. SMAC provides functionality for saving StarCraft II replays, which can be viewed using a freely available client. The resulting videos can be used to comment on interesting behaviours observed. Each independent run takes between 8 to 16 hours, depending on the exact scenario, using Nvidia Geforce GTX 1080 Ti graphics cards.


To make it easier to develop algorithms for SMAC, we have also open-sourced our software engineering framework PyMARL555PyMARL is available at . PyMARL has been designed explicitly with deep MARL in mind and allows for out-of-the-box experimentation and development.

PyMARL’s codebase is organized in a modular fashion in order to enable the rapid development of new algorithms, as well as provide implementations of current deep MARL algorithms to benchmark against. It is built on top of PyTorch to facilitate the fast execution and training of deep neural networks, and take advantage of the rich ecosystem built around it. PyMARL’s modularity makes it easy to extend, and components can be readily isolated for testing purposes.

Since the implementation and development of deep MARL algorithms come with a number of additional challenges beyond those posed by single-agent deep RL, it is crucial to have simple and understandable code. In order to improve the readability of code and simplify the handling of data between components, PyMARL encapsulates all data stored in the buffer within an easy to use data structure. This encapsulation provides a cleaner interface for the necessary handling of data in deep MARL algorithms, whilst not obstructing the manipulation of the underlying PyTorch Tensors. In addition, PyMARL aims to maximise the batching of data when performing inference or learning so as to provide significant speed-ups over more naive implementations.

PyMARL features implementations of the following algorithms: QMIX, QTRAN (Son et al., 2019), COMA (Foerster et al., 2018), VDN (Sunehag et al., 2017), and IQL (Tan, 1993) as baselines.

9 SMAC Results

In this section, we present the results of our experiments of QMIX and other existing multi-agent RL methods using the new SMAC benchmark.

The evaluation procedure is similar to the one in (Rashid et al., 2018). The training is paused after every timesteps during which test episodes are run with agents performing action selection greedily in a decentralised fashion. The percentage of episodes where the agents defeat all enemy units within the permitted time limit is referred to as the test win rate.

The architectures and training details are presented in Appendix C.3. A table of the results is included in Appendix C.4. Data from the individual runs are available at the SMAC repo (

Figure 7: Left: The median test win %, averaged across all 14 scenarios. Heuristic’s performance is shown as a dotted line. Right: The number of scenarios in which the algorithm’s median test win % is the highest by at least (smoothed).

Figure 7 plots the median test win percentage averaged across all scenarios in order to compare the algorithms across the entire SMAC suite. We also plot the performance of a simple heuristic AI that selects the closest enemy unit (ignoring partial observability) and attacks it with the entire team until it is dead, upon which the next closest enemy unit is selected. This is a basic form of focus-firing, which is a crucial tactic for achieving good performance in micromanagement scenarios. The relatively poor performance of the heuristic AI shows that the suite of SMAC scenarios requires more complex behaviour than naively focus-firing the closest enemy, making it an interesting and challenging benchmark.

Overall QMIX achieves the highest test win percentage and is the best performer on up to eight scenarios during training. Additionally, IQL, VDN, and QMIX all significantly outperform COMA, demonstrating the sample efficiency of off-policy value-based methods over on-policy policy gradient methods.

Figure 8: Three scenarios including QTRAN.

We also compare to QTRAN on 3 scenarios in Figure 8. We can see that QTRAN fails to achieve good performance on 3s5z and takes far longer to reach the performance of VDN and QMIX on 2s3z. Since it barely beats IQL on relatively easy scenarios, we do not perform a more comprehensive benchmarking of QTRAN. In preliminary experiments, we found the QTRAN-Base algorithm slightly more performant and more stable than QTRAN-Alt. For more details on the hyperparameters and architectures considered, please see the Appendix C.3.

Based on the overall performances of all algorithms, we broadly group the scenarios into three categories: Easy, Hard, and Super-Hard.

Figure 9: Easy scenarios. The heuristic AI’s performance shown as a dotted black line.

Figure 9 shows that IQL and COMA struggle even on the Easy scenarios, performing poorly on four of the five scenarios in this category. This shows the advantage of learning a centralised but factored centralised . Even though QMIX exceeds test win rate on all of five Easy scenarios, they serve an important role in the benchmark as sanity checks when implementing and testing new algorithms.

Figure 10: Hard scenarios. The heuristic AI’s performance shown as a dotted black line.

The Hard scenarios in Figure 10 each present their own unique problems. 2c_vs_64zg only contains 2 allied agents, but 64 enemy units (the largest in the SMAC benchmark) making the action space of the agents much larger than the other scenarios. bane_vs_bane contains a large number of allied and enemy units, but the results show that IQL easily finds a winning strategy whereas all other methods struggle and exhibit large variance. 5m_vs_6m is an asymmetric scenario that requires precise control to win consistently, and in which the best performers (QMIX and VDN) have plateaued in performance. Finally, 3s_vs_5z requires the three allied stalkers to kite the enemy zealots for the majority of the episode (at least 100 timesteps), which leads to a delayed reward problem.

Figure 11: Super Hard scenarios. The heuristic AI’s performance shown as a dotted black line.

The scenarios shown in Figure 11 are categorised as Super Hard because of the poor performance of all algorithms, with only QMIX making meaningful progress on two of the five. We hypothesise that exploration is a bottleneck in many of these scenarios, providing a nice testbed for future research in this domain.

10 Analysis

In this section, we aim to understand the reasons why QMIX outperforms VDN in our experiments. In particular, we consider two possible causes: 1) the inclusion of the central state in the mixing network and 2) the nonlinearity of the mixing network.

We find that inclusion of the central state is extremely important for performance but that it alone is not sufficient to explain QMIX’s increased performance. We further find that the mixing network learns nonlinear functions when required, but achieves good performance on the SMAC benchmark even when the learned solutions are mostly linear combinations of the agent’s utilities. Studying this phenomenon further, we conclude that it is the flexibility of the mixing network’s parameterisation, but not its nonlinearity, that accounts for QMIX’s superior performance in these tasks.

10.1 Role of the Central State

In order to disentangle the effects of the various components of the QMIX architecture, we consider the following two ablations:

  • VDN-S: The output of VDN is augmented by a state-dependent bias.

  • QMIX-NS: The weights of the mixing network are not a function of the state. The state-dependent bias remains.

Figure 12: Ablations for state experiments.

Figure 12 shows that VDN-S performs better than VDN, but still worse than QMIX, indicating that inclusion of the state accounts for some but not all of QMIX’s performance. On the easy 3s5z scenario, QMIX-NS performs very poorly, which is surprising since it is a strict generalisation of VDN-S. However, on the other two scenarios it outperforms VDN-S, indicating that the extra flexibility afforded by a learnt mixing over a fixed summation can be beneficial.

10.2 Role of Nonlinear Mixing

The results in Figure 12 show that both a state dependent bias on VDN (VDN-S) and a learnt state-independent mixing (QMIX-NS) do not match the performance of QMIX. Thus, we consider another ablation of QMIX:

  • QMIX-Lin: We remove the final layer and nonlinearity of the mixing network, making it a linear network. The state-dependant bias remains.

Figure 13: Ablations for mixing network linearity experiments.

Figure 13 shows that whilst QMIX-Lin matches QMIX on the easy 3s5z scenario, it underperforms QMIX on the other two scenarios we considered. This suggests that the ability to perform a nonlinear mixing, through the inclusion of a nonlinearity and additional hidden layer in the mixing network, plays an important role QMIX’s performance. To confirm this, we examine the function the mixing network learns.

Figure 14: The learnt mixing of QMIX on 2c_vs_64zg at the end of training for timesteps 0 (left) and 50 (right). Circles indicate the -values for the discrete joint-action space.

Figure 14 shows the learnt mixing of the network at the end of training for the 2c_vs_64zg scenario with two agents trained using QMIX. We generated a sample trajectory by greedily selecting actions and plotted the mixing function at different timesteps. The learnt function is approximately linear for the vast majority of the timesteps in the agent’s -values, similarly to the first timestep of the episode shown in Figure 14 (left). The only timesteps in which we observe a noticeable nonlinearity are at the end of the episode (53 timesteps total). When trained for longer we still observe that the the mixing function remains linear for the vast majority of timesteps.

Figure 15: The learnt mixing of QMIX on 3s5z at the end of training for timesteps 0 (left) and 50 (right), for agents 2 (top) and 7 (bottom).

Figure 15 shows the learnt mixing for 3s5z as a function of a single , keeping the -values for the other agent’s fixed. The mixing network clearly learns an approximately linear mixing, which is consistent across all timesteps and agents (only timesteps 0 and 50 for agents 2 and 7 are shown since they are representative of all other timesteps and agents).

This is a surprising result. QMIX is certainly capable of learning nonlinear mixing functions in practice, and thereby outperforming the more restrictive VDN decomposition. As an example, Figure 16 visualises the learnt mixing function for the didactic two-step game from section 5, clearly showing how a nonlinear fit allows QMIX to represent the true optimal value function.

Figure 16: The learnt mixing of QMIX on the two-step game from Section 5.

Yet, we observe mostly linear mixing functions in solutions to the SMAC benchmark tasks. If QMIX is learning a mostly linear mixing, then why does it outperform QMIX-Lin? One difference is that QMIX’s mixing network is compromised of two fully-connected layers, rather than the single linear layer of QMIX-Lin. If the nonlinearity is not essential, it may be that the extra layer in the mixing network is responsible for the performance increase. To test this hypothesis, we consider another ablation:

  • QMIX-2Lin: QMIX, without a nonlinear activation function in the mixing network.

QMIX-2Lin’s mixing network is compromised of two linear layers without any non-linearity between them. Thus, it can only learn a linear transformation of

into . QMIX-Lin’s mixing network is a single linear layer, thus both QMIX-Lin and QMIX-2Lin’s mixing networks share the same representational capacity. QMIX’s mixing network, on the other hand, has an ELU non-linearity between its two weight layers and thus can represent non-linear transformations of to .

We first consider a simple regression experiment in which the states, agent -values, and targets are randomly generated and fixed. Further details on the regression task are included in Appendix D.

Figure 17: The loss on a regression task.

We compare the loss of QMIX (with an ELU non-linearity), QMIX-Lin, and QMIX-2Lin in Figure 17, which illustrates that QMIX and QMIX-2Lin perform similarly, and both perform a faster optimisation of the loss than QMIX-Lin. Even though QMIX-Lin and QMIX-2Lin can both learn only linear mixing functions, their parametrisation of such a linear function are different. Having an extra layer is a better parametrisation in this scenario because it allows for gradient descent to optimise the loss faster.

Figure 18: Ablations for linear experiments.

Figure 18 confirms that the more flexible parameterisation of the mixing network is largely responsible for the increased performance. However, the results on 2c_vs_64zg show that QMIX performs slightly better than QMIX-2Lin, indicating that in some scenarios nonlinear mixing can still be beneficial. Figure 14 (right) shows an example of when such a nonlinearity is learnt on this task.

We also investigate changing the nonlinearity in the mixing network from ELU, which is largely linear, to Tanh.

Figure 19: The learnt mixing of QMIX on 2c_vs_64zg using a tanh nonlinearity at the end of training for timesteps 0 (left) and 50 (right).
Figure 20: The learnt mixing of QMIX on 3s5z, using a tanh nonlinearity, at the end of training for timesteps 0 (left) and 50 (right), for agents 2 (top) and 7 (bottom).
Figure 21: The Median test win % comparing QMIX with an ELU nonlinearity (QMIX) and QMIX with a tanh nonlinearity in the mixing network (QMIX-Tanh).

Figures 19 and 20 show the learnt mixings when using a tanh non-linearity. The mixing network using tanh learns a more nonlinear mixing, especially for 3s5z, than with ELU. Figure 21 shows how this translates to performance: there are perhaps some small gains in learning speed for some random seeds when using tanh. However, the effect of an additional layer (in improving the optimisation dynamics) is much more significant than encouraging a more non-linear mixing through the choice of nonlinearity.

10.3 Role of RNN in Agent Network

Figure 22: Comparing agent networks with and without RNNs (QMIX-FF) on two scenarios.

Finally, we compare the necessity of using an agent’s action-observation history by comparing the performance of an agent network with and without an RNN in Figure 22. On the easy scenario of 3s5z we can see that an RNN is not required to use action-observation information from previous timesteps, but on the harder scenario of 3s_vs_5z it is crucial to learning how to kite effectively.

11 Conclusion

This article presented QMIX, a deep multi-agent RL method that allows end-to-end learning of decentralised policies in a centralised setting and makes efficient use of extra state information. QMIX allows the learning of a rich joint action-value function, which admits tractable decompositions into per-agent action-value functions. This is achieved by imposing a monotonicity constraint on the mixing network.

To evaluate QMIX and other multi-agent RL algorithms, we introduced SMAC as a set of benchmark problems for cooperative multi-agent RL. SMAC focuses on decentralised micromanagement tasks and features 14 diverse combat scenarios which challenge MARL methods to handle partial observability and high-dimensional inputs. Additionally, we open-source PyMARL, a framework for cooperative deep MARL algorithms that features implementations of IQL, VDN, QMIX, QTRAN and COMA.

Our results on SMAC show that QMIX improves the final performance over other relevant deep multi-agent RL algorithms, most notably VDN. We include a detailed analysis through a series of ablations and visualisations for why QMIX outperforms VDN, showing that two components of QMIX are crucial to the performance the algorithm: a state-dependent bias and a learnt mixing of the agent’s utilities into that is conditioned on the state. Through our analysis, we found that the learnt mixing need only be linear to recover the majority of QMIX’s performance, but that the parametrisation for this linear function is an important consideration.

In the future, we aim to extend SMAC with new challenging scenarios that feature a more diverse set of units and require a higher level of coordination amongst agents. Particularly, we plan to make use of the rich skill set of StarCraft II units, and host scenarios that require the agents to utilise the features of the terrain. With harder multi-agent coordination problems, we aim to explore the gaps in existing multi-agent RL approaches and motivate further research in this domain.

There are several interesting avenues for future research:

  • Investigating the performance gap between value-based methods and policy-based methods. In our experiments, QMIX (and VDN) significantly outperform COMA in all scenarios, both in terms of sample efficiency and final performance. The primary differences between the methods are the use of -learning vs the Policy Gradient theorem, use of off-policy data from the replay buffer and the architecture used to estimate the joint-action -Values.

  • Expanding upon the joint-action -values representable by QMIX, to allow for the representation of coordinated behaviour. Importantly, this must scale gracefully to the deep RL setting.

  • Better algorithms for multi-agent exploration that go beyond -greedy. There have been many advances with regards to exploration in single-agent RL, dealing with both sparse and dense rewards environments. Taking inspiration from these, or developing entirely new approaches that improve exploration in a cooperative multi-agent RL setting is an important problem. SMAC’s super-hard scenarios provide a nice benchmark for evaluating these advances.

This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement number 637713). It was also supported by the Oxford-Google DeepMind Graduate Scholarship, the UK EPSRC CDT in Autonomous Intelligent Machines and Systems, Chevening Scholarship, Luys Scholarship and an EPSRC grant (EP/M508111/1, EP/N509711/1). This work is linked to and partly funded by the project Free the Drones (FreeD) under the Innovation Fund Denmark and Microsoft. The experiments were made possible by a generous equipment grant from NVIDIA.

We would like to thank Frans Oliehoek and Wendelin Boehmer for helpful comments and discussion. We also thank Oriol Vinyals, Kevin Calderone, and the rest of the SC2LE team at DeepMind and Blizzard for their work on the interface.


Appendix A Two Step Game

a.1 Architecture and Training

The architecture of all agent networks is a DQN with a single hidden layer comprised of units with a ReLU nonlinearity. Each agent performs independent greedy action selection, with . We set

. The replay buffer consists of the last 500 episodes, from which we uniformly sample a batch of size 32 for training. The target network is updated every 100 episodes. The learning rate for RMSprop is set to

. We train for timesteps. The size of the mixing network is units. All agent networks share parameters, thus the agent id is concatenated onto each agent’s observations. We do not pass the last action taken to the agent as input. Each agent receives the full state as input.

Each state is one-hot encoded. The starting state for the first timestep is State

. If Agent takes Action A, it transitions to State (whose payoff matrix is all s). If agent takes Action B in the first timestep, it transitions to State .

a.2 Learned Value Functions

The learned value functions for the different methods on the Two Step Game are shown in Tables 5 and 6.

(a) State 6.94 6.94 6.35 6.36   State A 6.99 7.02 6.99 7.02   State B -1.87 2.31 2.33 6.51

(b) 6.93 6.93 7.92 7.92   7.00 7.00 7.00 7.00   0.00 1.00 1.00 8.00

(c) 6.94 6.93 7.93 7.92   7.03 7.02 7.02 7.01   0.00 1.01 1.01 8.02

(d) 6.98 6.97 6.37 6.36   7.01 7.02 7.02 7.04   -1.39 2.57 2.67 6.58

(e) 6.95 6.99 6.18 6.22   6.99 7.06 7.01 7.09   -1.21 2.73 2.46 6.40

Table 5: on the 2 step game for (a) VDN, (b) QMIX, (c) QMIX-NS, (d) QMIX-Lin and (e) VDN-S
Agent 6.96 4.47
6.98 7.00
0.50 4.50

Agent 5.70 5.78
7.00 7.02
0.50 4.47
Table 6: for IQL on the 2 step game

a.3 Results

Figure 23 shows the loss for the different methods. Table 7 shows the final testing reward for each method.

Figure 23:

Loss for all six methods on the Two Step Game. The mean and 95% confidence interval is shown across 30 independent runs.

7 7 7 8 7 8
Table 7: The final Test Reward acheived.

Appendix B Random Matrix Games

b.1 Architecture and Training

The architecture of all agent networks is a DQN with 2 hidden layers comprised of units with a ReLU nonlinearity. Each agent performs independent greedy action selection, with . The replay buffer consists of the last 500 episodes, from which we uniformly sample a batch of size 32 for training. The target network is updated every 100 episodes. The learning rate for RMSprop is set to . We train for timesteps. The mixing network is identical to the SMAC experiments. All agent networks share parameters, thus the agent id is concatenated onto each agent’s observations. We do not pass the last action taken to the agent as input. Each agent receives the full state (a vector of s with dimension 5) as input.

Appendix C Smac

c.1 Scenarios

Perhaps the simplest scenarios are symmetric battle scenarios, where the two armies are composed of the same units. Such challenges are particularly interesting when some of the units are extremely effective against others (this is known as countering), for example, by dealing bonus damage to a particular armour type. In such a setting, allied agents must deduce this property of the game and design an intelligent strategy to protect teammates vulnerable to certain enemy attacks.

SMAC also includes more challenging scenarios, for example, in which the enemy army outnumbers the allied army by one or more units. In such asymmetric scenarios it is essential to consider the health of enemy units in order to effectively target the desired opponent.

Lastly, SMAC offers a set of interesting micro-trick challenges that require a higher-level of cooperation and a specific micro trick to defeat the enemy. An example of such scenario is the corridor scenario (Figure 6d). Here, six friendly Zealots face 24 enemy Zerglings, which requires agents to make effective use of the terrain features. Specifically, agents should collectively wall off the choke point (the narrow region of the map) to block enemy attacks from different directions. The 3s_vs_5z scenario features three allied Stalkers against five enemy Zealots (Figure 1a). Since Zealots counter Stalkers, the only winning strategy for the allied units is to kite the enemy around the map and kill them one after another. Some of the micro-trick challenges are inspired by StarCraft Master challenge missions released by Blizzard (Blizzard Entertainment, 2012).

c.2 Environment Setting

SMAC makes use of the StarCraft II Learning Environment (SC2LE) (Vinyals et al., 2017) to communicate with the StarCraft II engine. SC2LE provides full control of the game by making it possible to send commands and receive observations from the game. However, SMAC is conceptually different from the RL environment of SC2LE. The goal of SC2LE is to learn to play the full game of StarCraft II. This is a competitive task where a centralised RL agent receives RGB pixels as input and performs both macro and micro with the player-level control similar to human players. SMAC, on the other hand, represents a set of cooperative multi-agent micro challenges where each learning agent controls a single military unit.

SMAC uses the raw API of SC2LE. Raw API observations do not have any graphical component and include information about the units on the map such as health, location coordinates, etc. The raw API also allows sending action commands to individual units using their unit IDs. This setting differs from how humans play the actual game, but is convenient for designing decentralised multi-agent learning tasks.

Furthermore, to encourage agents to explore interesting micro strategies themselves, we limit the influence of the StarCraft AI on our agents. In the game of StarCraft II, whenever an idle unit is under attack, it automatically starts a reply attack towards the attacking enemy units without being explicitly ordered. We disable such automatic replies towards the enemy attacks or enemy units that are located closely by creating new units that are the exact copies of existing ones with two attributes modified: Combat: Default Acquire Level is set to Passive (default Offensive) and Behaviour: Response is set to No Response (default Acquire). These fields are only modified for allied units; enemy units are unchanged.

The sight and shooting range values might differ from the built-in sight or range attribute of some StarCraft II units. Our goal is not to master the original full StarCraft II game, but rather to benchmark MARL methods for decentralised control.

The game AI is set to level 7, very difficult. Our experiments, however, suggest that this setting does significantly impact the unit micromanagement of the built-in heuristics.

c.3 Architecture and Training

The architecture of all agent networks is a DRQN with a recurrent layer comprised of a GRU with a 64-dimensional hidden state, with a fully-connected layer before and after. Exploration is performed during training using independent -greedy action selection, where each agent performs -greedy action selection over its own . Throughout the training, we anneal linearly from to over time steps and keep it constant for the rest of the learning. We set for all experiments. The replay buffer contains the most recent episodes. We sample batches of 32 episodes uniformly from the replay buffer, and train on fully unrolled episodes, performing a single gradient descent step after every episode. The target networks are updated after every training episodes. The Double -Learning update rule from (Van Hasselt et al., 2016) is used for all -Learning variants (IQL, VDN, QMIX and QTRAN).

To speed up the learning, we share the parameters of the agent networks across all agents. Because of this, a one-hot encoding of the agent_id is concatenated onto each agent’s observations. All neural networks are trained using RMSprop666We set and do not use weight decay or momentum. with learning rate .

The mixing network consists of a single hidden layer of units, utilising an ELU non-linearity. The hypernetworks consist of a feedforward network with a single hidden layer of units with a ReLU non-linearity. The output of the hypernetwork is passed through an absolute function (to acheive non-negativity) and then resized into a matrix of appropriate size.

The architecture of the COMA critic is a feedforward fully-connected neural network with the first 2 layers having 128 units, followed by a final layer of units. We set . We utilise the same -floor scheme as in (Foerster et al., 2018) for the agents’ policies, linearlly annealing from 0.5 to 0.01 over 100k timesteps. For COMA we roll-out 8 episodes and train on those episodes. The critic is first updated, performing a gradient descent step for each timestep in the episode, starting with the final timestep. Then the agent policies are updated by a single gradient descent step on the data from all 8 episodes.

The architecture of the centralised for QTRAN is similar to the one used in (Son et al., 2019). The agent’s hidden states ( units) are concatenated with their chosen action ( units) and passed through a feedforward network with a single hidden layer and a ReLU non-linearity to produce an agent-action embedding ( units). The network is shared across all agents. The embeddings are summed across all agents. The concatentation of the state and the sum of the embeddings is then passed into the network. The network consists of 2 hidden layers with ReLU non-linearities with units each. The network takes the state as input and consists of 2 hidden layers with ReLU non-linearities with units each. We set and .

We also compared a COMA style architecture in which the input to is the state and the joint-actions encoded as one-hot vectors. For both architectural variants we also tested having 3 hidden layers. For both network sizes and architectural variants we performed a hyperparameter search over and on all three of the scenarios we tested QTRAN on and picked the best performer out of all configurations.

c.4 Table of Results

Table 8 shows the final median performance (maximum median across the testing intervals within the last of training) of the algorithms tested. The mean test win %, across 1000 episodes, for the heuristic-based ai is also shown.

2s_vs_1sc 100 98 100 100 0

75 43 97 99 90

10 1 84 97 42

21 31 91 97 81

34 7 97 97 12

7 0 21 58 0

99 64 94 85 43

49 1 70 70 0

45 0 91 87 0

0 0 2 2 0

0 0 0 3 0

0 0 0 49 0

0 0 1 69 0

0 0 0 1 0
Table 8: The Test Win Rate % of the various algorithms.

Appendix D Regression Experiment

For the regression experiment we simulate a task with agents. There are 10 states, of dimensionality 10, in which each dimension is uniformly sampled from . For each of the 10 states, the agent -values are uniformly sampled from . The targets for each state are uniformly sampled from . The agent -values, targets and states are kept fixed, only the parameters of the mixing network may change.

We use a mixing embed dimension of 32, and train for a total of 2000 timesteps. At each timestep we uniformly sample a state, add it to the replay buffer of size 200, and execute a training step. Each training step consists of sampling a minibatch of 32 from the replay buffer and minimising the loss between the targets and the network’s outputs.