Proc. Int. Conf. on Systems, Man and Cybernetics, The Hague, The Netherlands, Oct 2004.

**Anytime algorithms for multiagent decision making**

**using coordination graphs**

### ∗

### N. Vlassis

### R. Elhorst

### J. R. Kok

### Informatics Institute, University of Amsterdam, The Netherlands

### {vlassis,reinhrst,jellekok}@science.uva.nl

**Abstract – Coordination graphs provide a tractable **

*frame-work for cooperative multiagent decision making by *
*decom-posing the global payoff function into a sum of local terms.*
*In this paper we review some distributed algorithms for *
*ac-tion selecac-tion in a coordinaac-tion graph and discuss their pros*
*and cons. For real-time decision making we emphasize the*
*need for anytime algorithms for action selection: these are*
*algorithms that improve the quality of the solution over time.*
*We describe variable elimination, coordinate ascent, and the*
*max-plus algorithm, the latter being an instance of the *
*be-lief propagation algorithm in Bayesian networks. We discuss*
*some interesting open problems related to the use of the *
*max-plus algorithm in real-time multiagent decision making.*

**Keywords: Multiagent systems, real-time systems, decision**

making, coordination graph, variable elimination, coordinate ascent, max-plus algorithm.

**1 Introduction**

Multiagent Systems (MAS) is an exciting new field with many theoretical and practical challenges [11, 8]. A MAS consists of a group of rational agents that can potentially in-teract with each other. These agents may have identical inter-ests (like a team of soccer-playing robots, Fig. 1), conflicting interests (like two poker playing programs), or more general interests (like in e-commerce). A fundamental issue in MAS is how to implement agent-centric behavior that brings about desired system-wide behavior.

In this paper we are interested inteamMAS, or fully co-operative multiagent systems where all agents share a com-mon goal. A key aspect in such a system is the problem of coordination: how to ensure that the local (individual) deci-sion making of each agent can produce globally good solu-tions for the team. One could use a centralized agent to solve the coordination problem: this agent could decide what ac-tion each individual agent should take, and then communi-cate these choices to each agent. However, such a system is not robust since a malfunction of the centralized agent could compromise the performance of the whole team.

Instead, in a team MAS we would like to have decentral-izedcoordination: the agents should decide what actions to

∗**0-7803-8566-7/04/$20.00 c**_{
}**2004 IEEE.**

Figure 1: A robot soccer team is an example of a real-time cooperative multiagent system.

take by using a distributed protocol. In particular, when real-time decision making is in order, we would like such a proto-col to be fast, robust to communication failures, andanytime. The latter suggests that we would like the quality of the so-lution to improve over time, and the agents should be able to report at any time the best solution (joint action) they have found so far. After some finite time we would like our proto-col to converge to the optimal solution.

PSfrag replacements 2 1 3 4 f12 f13 f34

Figure 2: A coordination graph for a 4-agents problem.

**2 Coordination graphs and variable**

**elimination**

We adopt a decision-theoretic approach to the coordina-tion problem of n agents. In each time step we assume that each agent i chooses its individual action aifrom a set

Ai, and the selectedjointaction a = (a1, . . . , an)induces

payoff to the team u(a). The coordination problem is to
find the optimal joint action a∗ _{that maximizes u(a), i.e.,}

a∗ = arg maxau(a). An obvious approach would involve

enumerating all possible joint actions and selecting the one that maximizes u(a), but this is clearly impractical: the joint action space ×iAi is exponentially large in the number of

agents n. A very large memory would be needed just to store the payoffs, apart from the cost of actually computing the op-timal action.

It turns out that in many practical problems a complete enumeration of all joint actions is unnecessary: the payoff matrix u(a) is sparse. This insight is exploited in the frame-work of coordination graphs (CG) [1]. A CG is a graph G= (V, E)where each node in V represents an agent, and each edge in E defines a coordination dependency between two agents. An example graph with n = 4 agents is shown in Fig. 2.

The particular structure of a CG induces a decomposition of the global payoff function u(a) into a linear combination of local payoff functions, each involving only few agents. For instance, in the graph of Fig. 2 the payoff function can be written:

u(a) = f12(a1, a2) + f13(a1, a3) + f34(a3, a4). (1)

Here, f13for instance involves only agents 1 and 3, and for

each pair of actions (a1, a3) contributes to the team local

payoff f13(a1, a3).

In [1] an exact algorithm was proposed for finding the
op-timal joint action a∗ _{= arg max}

au(a)in a CG. The

algo-rithm, calledvariable elimination(VE), is an iterative maxi-mization procedure in which agents are eliminated one after the other from the graph.

We will illustrate VE on the above example. We start by eliminating agent 1 in (1). We collect all local payoff func-tions that involve agent 1, these are f12and f13. The

maxi-mum of u(a) can then be written

max a u(a) = maxa2,a3,a4 n f34(a3, a4)+ max a1 f12(a1, a2) + f13(a1, a3) o . (2) Next we perform the inner maximization over the actions of agent 1. For each combination of actions of agents 2 and 3, agent 1 must choose an action that maximizes f12+ f13.

This results in a best-response function (conditional strategy) B1(a2, a3)for agent 1, given the actions of agents 2 and 3.

The above maximization and the computation of the best-response function of agent 1 define a new payoff function φ23(a2, a3) = maxa1[f12(a1, a2) + f13(a1, a3)]that is

in-dependent of a1. Agent 1 has been eliminated. The

maxi-mum (2) becomes max

a u(a) = maxa2,a3,a4

f34(a3, a4) + φ23(a2, a3). (3)

We can now eliminate agent 2 as we did with agent 1. In (3), only φ23involves a2, and maximization of φ23over a2gives

the best-response function B2(a3)of agent 2 which is a

func-tion of a3only. This in turn defines a new payoff function

φ3(a3), and agent 2 is eliminated. Now we can write

max

a u(a) = maxa3,a4

f34(a3, a4) + φ3(a3). (4)

Agent 3 is eliminated next, resulting in B3(a4) and a

new payoff function φ4(a4). Finally, maxau(a) =

maxa4φ4(a4), and since all other agents have been

elimi-nated, agent 4 can simply choose an action a∗

4that maximizes

φ4(a4).

The above procedure computes an optimal action only for the last eliminated agent (assuming that the graph is con-nected). For the other agents it computes only conditional strategies. A second pass in the reverse elimination order is needed so that all agents compute their optimal (uncondi-tional) actions from their best-response functions. Thus, in the above example, plugging a∗

4into B3(a4)gives the

opti-mal action a∗

3of agent 3. Similarly, we get a∗2from B2(a∗3)

and a∗

1from B1(a∗2, a∗3), and thus we have computed the joint

optimal action a∗ _{= (a}∗

1, a∗2, a∗3, a∗4). Note that one agent

may have more than one best-response actions, in which case it can arbitrarily choose one of them (and then communicate it to each agent that needs it).

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0.6 0.65 0.7 0.75 0.8 0.85 0.9 0.95 1

time/time needed for VE algorithm

payoff/maximum payoff

Figure 3: CA vs. VE: 800 loosely connected agents.

would be more appropriate, one that improves the quality of the solution over time and eventually (given sufficient time) computes the optimal solution.

**3 Anytime algorithms for action **

**selec-tion in coordinaselec-tion graphs**

We describe here two classes of anytime algorithms for ac-tion selecac-tion in CGs, as alternatives to variable eliminaac-tion, that are more appropriate for real-time systems.

**3.1 Coordinate ascent**

A simple anytime algorithm for action selection is a
coor-dinate ascent(CA) with random restarts. Initially, each agent
chooses its individual action, for instance randomly or using
some local heuristics, resulting in a joint action a(0)_{. At time}

step t, all agents fix their actions except for (a randomly se-lected) agent i. Using (1), this agent computes its conditional payoff function u(ai|a

(t)

−i), where a (t)

−i refers to the vector of

fixed actions of all agents except agent i. Then agent i max-imizes u(ai|a

(t)

−i)over its individual actions ai, producing

a(t+1)i . This action then replaces a (t)

i in a(t) to give a(t+1),

another agent is selected, and so on, until u(a(t+τ )_{)}_{does not}

improve anymore. The latter is a local maximum of the
pay-off function u(a). If more time is available, another starting
configuration a(0)_{is randomly selected and the above }

proce-dure is repeated. When the deadline expires, the joint action with the highest payoff is reported.

Note that, by construction, the payoff function u(a) in-creases in each step of the algorithm, and therefore the re-sulting algorithm is anytime. Moreover, the graphical rep-resentation of (1) suggests a message passing scheme for action updating: after an agent computes a new individual action, it communicates this information only to its immedi-ate neighbors in the graph. This way, a global solution can be computed by only local interactions. CA has been used in [2], in a problem involving global payoff functions with local constraints. 0 0.001 0.002 0.003 0.004 0.005 0.006 0.007 0.008 0.009 0.01 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

time/time needed for VE algorithm

payoff/maximum payoff

Figure 4: CA vs. VE: 13 densely connected agents.

The CA algorithm constitutes an efficient, anytime algo-rithm that admits a distributed implementation. In many practical problems it can compute the optimal solution (or get very close to it) in a fraction of the time that VE takes. In Fig. 3-4 we show some results comparing CA with VE in randomly generated graphs. In both plots we show the maxi-mum payoff computed by CA (% fraction relative to VE) vs. the total runtime of CA (% fraction relative to VE). In most cases CA computes solutions close to optimal in a fraction of the time that VE needs.

However, in general it is difficult to provide guarantees on the behavior of CA. Depending on the shape of the func-tion u(a), CA may need many random restarts to reach the global maximum of u(a). A more sophisticated approach would be to search for the optimal joint action using a popu-lation of candidate configurations, properly selected in each optimization step via evolutionary techniques [6].

**3.2 The max-plus algorithm**

Themax-plusalgorithm is analogous to the sum-product or belief propagation algorithm used for inference in graphi-cal models [7, 5, 9, 10]. It is easy to see that action selection in a CG is equivalent to computing themaximum a posteriori (MAP) configuration in an (unnormalized) undirected graph-ical model defined through a set of potential functions as in (1). In the max-plus algorithm—when viewed in the con-text of multiagent coordination—the agents exchange mes-sages with each other, where each message can be regarded as a local payoff function. A nice property of max-plus is that upon convergence, and depending on the structure of the graph, the optimal joint action can be computed by only local computations. In the sequel we follow [9], translating their results into our multiagent decision making problem.

Suppose that we have n agents, and a coordination graph G= (V, E)with V vertices and E edges that defines a pay-off function as a sum of 2-agent local paypay-offs:

u(a) = X

(i,j)∈E

Here (i, j) denotes a pair of neighboring agents (an edge in G), and fij is a local payoff function that maps a pair of

actions (ai, aj) to a real number fij(ai, aj). In each time

step, each agent i (node in G) sends a message µijto each of

its neighbors j ∈ Γ(i), where µijis a (local) payoff function

that maps an action ajof agent j to a real number µij(aj).

We further define: gi= X j∈Γ(i) µji, gij = fij+ X k∈Γ(i)\j µki+ X k∈Γ(j)\i µkj,

where the notation Γ(i) \ j means all neighbors of node i except node j. Clearly, gi is a 1-agent payoff function and

gijis a 2-agent payoff function.

Then we can easily show (by direct substitution) that if we have reached a ‘fixed point’ where the communicated mes-sages among the agents do not change anymore, then the set of local payoff functions gi, gijdefine a reparametrization of

the original payoff function: u(a) =X i∈V gi+ X (i,j)∈E (gij− gi− gj). (6)

Moreover, suppose that this fixed point has been reached by messages defined as follows:

µij(aj) = max ai fij(ai, aj) + X k∈Γ(i)\j µki(ai) . (7)

Then, we can easily verify that the following consistency property holds:

gi(ai) = max aj

gij(ai, aj) (8)

where j is an arbitrary neighbor of i.

From the above, the following important results follow [7, 9]. When the graph G is cycle-free (a tree), then max-plus always converges after a finite number of steps to a fixed point of the above message passing procedure. In this case, for the local functions gi, gijholds:

gi(ai) = max {a0|a0 i=ai} u(a0), gij(ai, aj) = max {a0|(a0 i,a0j)=(ai,aj)} u(a0).

Consequently, if each individually (per agent) optimal action a∗

i = arg maxaigi(ai)is unique for all i, then the globally

optimal action a∗ _{= arg max}

au(a) is also unique and has

elements a∗ _{= (a}∗

i)computed by only local optimizations

(each node maximizes gi(ai)separately). If the local

max-imizers are not unique, an optimal joint action can still be computed by a straightforward dynamic programming tech-nique [9, sec. 3.1].

The importance of the above result is that a difficult global optimization problem is transformed to a set of easy local

optimization problems, one for each agent, using local mes-sage passing. Under the conditions stated above, this auto-matically defines an anytime algorithm: assuming that each agent can evaluate u(a) for any a, the anytime solution is formed by the best (in terms of u) vector of local maximiz-ers a∗

i = arg maxaigi(ai)found so far. According to the

above, after a finite number of steps we are guaranteed to find the optimal joint action.

In graphs with cycles, the above result does not hold any-more, and there are no guarantees that either max-plus will converge or that the local maximizers a∗

i = arg maxaigi(ai)

will correspond to the global optimum. In [9] it was shown that a fixed point of message passing exists in graphs with cycles, but there is no known algorithm yet that can prov-ably converge to such a solution. Yet, bounds are available that characterize the quality of the max-plus solution if the algorithm converges [9].

**4 Discussion and conclusions**

We reviewed the framework of coordination graphs (CG) for multiagent coordination, and described the three existing algorithms for action selection in a CG, variable elimination, coordinate ascent, and the max-plus algorithm.

Variable elimination (VE) computes a solution by two passes over the graph. In the forward pass, agents are succes-sively eliminated from the graph, until one agent is left for which decision making is easy. A second pass in the reverse elimination order is then employed to ensure that each agent computes its component of the optimal joint action. VE can be shown to always converge to the exact solution, indepen-dently of the elimination order and the structure of the graph, and it can be effective in loosely connected graphs. Its worst-case time complexity, however, is exponential in the number of agents involved in the graph, and therefore it can be slow in densely connected graphs. Moreover, VE is not appro-priate for real-time systems as it requires that both passes terminate before a solution can be reported.

Coordinate ascent (CA) with random restarts is a very sim-ple method in which each agent optimizes its own action only, given that the actions of all other agents remain fixed. This is repeated for all agents iteratively, until a local maxi-mum of the global payoff function has been reached. A new initial configuration is then chosen, and the process is re-peated. The method is very effective in practice, and it can be implemented in a distributed fashion [2]. CA will com-pute the optimal joint action in the limit of an infinite number of random restarts, but it is difficult to characterize its speed of convergence on arbitrary graphs.

the case of cycle-free graphs and the existence of fixed points in arbitrary graphs. However, there is no message passing schedule yet that is provably convergent.

We see a few interesting open issues for further research, in particular related to the use of the max-plus algorithm. First, it would be useful to further characterize the anytime behavior of the algorithm, even in graphs without cycles. For instance, we would like to have a message passing sched-ule that ensures a monotone (and fast) increase of the global payoff value in each step. The results that we mentioned above guarantee that in cycle-free CGs, under mild condi-tions, max-plus will converge to the optimal joint action, but we would like to ensure high speed of convergence on the average.

A second issue is related to the convergence of max-plus on arbitrary graphs, which is an open problem. In recent work [10], a ‘reweighted’ version of max-plus has been pro-posed, that exhibits better convergence behavior than the original algorithm and for which stronger theoretical results can be formulated. It would be interesting to further inves-tigate the applicability of these algorithms in the context of multiagent coordination.

Another line of research would be to use a message pass-ing algorithm like max-plus for sequential decision makpass-ing, like in Markov decision processes or reinforcement learn-ing [1, 4]. Finally, from an application point of view, it would be interesting to test some of the above methods on large-scale problems like robot soccer [3].

**Acknowledgments**

We thank Carlos Guestrin and Taylan Cemgil for help-ful discussions. This research is supported by PROGRESS, the embedded systems research program of the Dutch orga-nization for Scientific Research NWO, the Dutch Ministry of Economic Affairs and the Technology Foundation STW, project AES 5414.

**References**

[1] C. Guestrin, D. Koller, and R. Parr. Multiagent plan-ning with factored MDPs. InAdvances in Neural Infor-mation Processing Systems 14. The MIT Press, 2002. [2] G. ˙Inalhan, D. M. Stipanovi´c, and C. J. Tomlin.

Decen-tralized optimization with application to multiple air-craft coordination. InProc. IEEE Int. Conf. on Deci-sion and Control, Las Vegas, Nevada, 2002.

[3] J. R. Kok, M. T. J. Spaan, and N. Vlassis. Multi-robot decision making using coordination graphs. In Proc. 11th Int. Conf. on Advanced Robotics, Coimbra, Por-tugal, June 2003.

[4] J. R. Kok and N. Vlassis. Sparse cooperative Q-learning. InProc. 21st Int. Conf. on Machine Learning, Banff, Canada, July 2004.

[5] F. R. Kschischang, B. J. Frey, and H.-A. Loeliger. Fac-tor graphs and the sum-product algorithm.IEEE Trans. on Information Theory, 47:498–519, 2001.

[6] H. M¨uhlenbein and T. Mahnig. FDA—a scalable evo-lutionary algorithm for the optimization of additively decomposed functions. Evolutionary Computation, 7:353–376, 1999.

[7] J. Pearl.Probabilistic Reasoning in Intelligent Systems. Morgan Kaufman, San Mateo, 1988.

[8] N. Vlassis. A concise introduction to multi-agent systems and distributed AI. Informatics Institute, University of Amsterdam, Sept. 2003. http://www.science.uva.nl/˜vlassis/cimasdai.

[9] M. Wainwright, T. Jaakkola, and A. Willsky. Tree con-sistency and bounds on the performance of the max-product algorithm and its generalizations. Technical report, P-2554, LIDS-MIT, 2002.

[10] M. Wainwright, T. Jaakkola, and A. Willsky. MAP estimation via agreement on (hyper)trees: Message-passing and linear programming approaches. Technical report, UCB/CSD-03-1269, UC Berkeley, 2003. [11] G. Weiss, editor. Multiagent Systems: a Modern