An asynchronous complete method for general distributed constraint optimization

1
An asynchronous complete method for general
distributed constraint optimization

• Pragnesh Jay Modi, Wei-Min Shen, Milind Tambe and
  Makoto Yokoo

2
Overview

• Problem description
• Previous work
• Simple Adopt
• Adopt
• Evaluation
• Conclusions

3
Problem Description

• Constraint Satisfaction Problems (CSP) tuple
  ltV, D, Cgt
• DisCSP distributed version of CSP in general,
  one variable per agent
• DCOP solutions have a quality or cost
  (constraints are functions, not predicates)

4
DCOP formalization

• DCOP ltV, D, C, Fgt
• Variables set V v1, v2, , vn
• Domains set D D1, D2, , Dn
• Constraints set C fijDi x Dj ?N U 8 , where
  i,j1..n, i ? j
• Evaluation function
• ,where xi?di, xj?dj
• Objective minimize F(A) (ideally 0)

5
Previous work
6
DCOP example

• Vx1,x2,x3,x4
• D0,1, 0,1, 0,1, 0,1
• Constraints (can be different)

7
Simple Adopt preamble

• All agents are in a fixed total priority order
• Definition view vw (xi,di), (xj,dj),
• Definition compatible views dont differ in any
  variable assignments
• Definition local cost
• where xi?di, xj ?dj in vw

8
Problem structure
VALUE
VIEW
Constraint graph
Priority ordering
Message flow
9
Simple Adopt algorithm overview

• Each agent does
• Choose a variable value from its domain
• Send it to linked descendents through VALUE
• Wait for incoming messages and respond
• When received VALUE
• Store the received value in Currentvw (its
  context)
• Compute lower bound for this Currentvw
• Send this bound to its parent through a VIEW
  message
• When received VIEW
• if lower bound increased, try to find another
  value send it

10
Simple Adopt algorithm details 1

• Currentvw Current view of linked ancestors
  values
• xi/di Local variable/value
• c(d) Current lower bound on cost for subtree
  rooted at child, given xi chooses value d
• proc Initialize
• Currentvw ? di ? null
• for all d in Di
• c(d) ? 0
• go to Hill_climb

11
Simple Adopt algorithm details 2

• proc Hill_climb
• for all d in Di
• //e(d) is xis estimate of cost if it chooses d
• e(d) ? d(xi, Currentvw U (xi,d)) c(d)
• choose d that minimizes e(d)
• prefer current value di in case of tie
• di ? d
• SEND VALUE((xi,di)) to all linked descendents
• SEND VIEW(Currentvw, e(di)) to parent

Note 1 for completeness
12
Simple Adopt algorithm details 3

• proc when_received_value(xi,di)
• update Currentvw with (xi,di)
• if(Currentvw changed) then
• for all d in Di
• c(d) ? 0
• go to Hill_climb
• proc when_received_view(vw,cost)
• d ? value of xi in vw
• if(vw compatible with Currentvw U (xi,d) then
• c(d) ? max(c(d), cost)
• if( c(d) changed) then
• go to Hill_climb

Note 2 linear space reqs
Problem 1 resetting all discovered costs
Note 3 ignoring messages
13
Example run
x10
x11
x11
cost1, vw(x1,0)
cost0, vw(x1,1)
x11
cost2, vw(x1,0), (x2,0)
x11
x2 0
x20
x21
cost0, vw(x1,1), (x2,1)
cost2, vw(x1,1), (x2,0)
x21
x21
x3 0
x30
x4 0
x4 0
x31
x4 0
x41
x30
x31
cost1, vw(x2,0), (x3,0)
cost0, vw(x2,1), (x3,1)
cost1, vw(x2,0), (x3,0)
14
Simple Adopt ? Adopt

• Improvement 1
• Problem unnecessary deletion of stored lower
  bounds at context changes (upon receiving value
  messages)
• Solution store context information for all
  domain values (linear space requirements,
  preserves completeness)
• X2 when received VIEW (vw,a)
• store c(d)a
• store context(d)vw (vw doesnt contain x1)
• X2 when received VALUE(x1newval) check
  context(d) against Currentvw of x2 if
  compatible, then dont delete c(d)

x1
x1newval
x2
c(d)a
x4
x3
15
Simple Adopt ? Adopt
xi d1,d2

• Improvement 2
• Problem repeated exploration of portions of the
  search space at context changes (upon receiving
  value messages)
• Solution send cost thresholds to linked
  descendents

xid1,c(d1)a
costbgta
costa
xid2
xid1
xj
xjj
xl
xk
16
Evaluation

• Graph coloring with 3 colors

Table 1. GraphColor (Link density2)
Table 2. GraphColor (Link density3)
17
Conclusions

• Adopt algorithm for distributed constraint
  optimization
• Idea increase lower bounds on solution quality
• Complete converges to solution (proof provided)
• Asynchronous enables concurrency
• Significant improvements over SynchBB
• Still some (potential) problems

18
Thank you!
19
ANNEX Adopt algorithm details 1

• Currentvw Current view of linked ancestors
  values
• xi/di Local variable/value
• c(d) Current lower bound on cost for subtree
  rooted at child, given xi chooses value d
• proc Initialize
• Currentvw ? di ? null threshold ? 0
• for all d in Di
• c(d) ? 0
• context(d) ?
• Hill_climb

20
ANNEX Adopt algorithm details 2

• proc Hill_climb
• for all d in Di
• e(d) ? d(xi, Currentvw U (xi,d)) c(d)
• choose d that minimizes e(d)
• prefer current value di in case of tie
• if e(di)gtthreshold
• di ? d
• childLimit?max(c(di),threshold-d(xi,Currentvw U
  (xi,di)))
• SEND VALUE ((xi di), childLimit) to descendents
• only choose variables relevant to local cost
• Neighborvw (xj,dj) in Currentvw xj neighbor
  of xi
• viewContext?Neighborvw Uunion of contexts of di
  in D
• to preserve completeness VIEW is for best
  value d, not current value di
• SEND VIEW, viewContext, e(d)) to parent

21
ANNEX Adopt algorithm details 3

• proc when_received_value(xj,dj, limit)
• update Currentvw with (xj,dj)
• for all d in Di
• if(context(d) incompatible with Currentvw)
• c(d) ? 0
• context(d) ?
• if(xj is parent)
• threshold ? limit
• go to Hill_climb

Change from Simple Adopt
22
ANNEX Adopt algorithm details 4

• proc when_received_view(vw,cost)
• d ? value of xi in vw
• if vw contains (xi,d) //child is my neighbor
• remove (xi,d) from vw
• if vw compatible with Currentvw and cost gt c(d)
  then
• c(d) ? cost
• context(d) ? vw
• else //child is not my neighbor
• for all d in Di
• if vw compatible with Currentvw and cost gt c(d)
  then
• c(d) ? cost
• context(d) ? vw
• end if
• if( c(di) changed) then
• go to Hill_climb