Multi-Agent Pathfinding with Simultaneous Execution of Single-Agent Primitives

Multi-agent pathfinding is a challenging combinato- rial problem that involves multiple agents moving on a graph from a set of initial nodes to a set of desired goals without inter-agent collisions. Searching the com- posite space of all agents has exponential complexity and does not scale well. Decoupled methods are more efficient but are generally incomplete. There are, how- ever, polynomial time algorithms, which utilize single or few-agents primitives with completeness guarantees. One limitation of these alternatives is that the resulting solution is sequential, where only one agent moves at a time. Such solutions are of low quality when compared to methods where multiple agents can move simultane- ously. This work proposes an algorithm for multi-agent pathfinding that utilizes similar single-agent primitives but allows all agents to move in parallel. The paper de- scribes the algorithm and its properties. Experimental comparisons suggest that the resulting paths are con- siderably better than sequential ones, even after a post- processing, parallelization step, as well as solutions re- turned by decoupled and coupled alternatives. The ex- periments also suggest good scalability and competitive computational performance.

Transcript

1. Qandeel Sajid, University of Nevada, Reno Ryan Luna, Rice University Kostas Bekris, Rutgers University SoCS 2012
2. Motivation   Move multiple agents from their initial positions to their desired goals without collision Warehouse Management Planetary Exploration Intelligent Transportation Assembly and Disassembly Autonomous Mining Computer Games
4. Multi-Agent Pathfinding   Compute a set of compatible paths on a discrete graph   Coupled techniques   Search the composite graph   Optimal and/or complete   Exponentially complex   Decoupled techniques   Plan for individual agents   Fast approximate solutions   Incomplete and suboptimal 1 2
5. Coupled Techniques Standley 2010, 2011 Operator Decomposition Wagner, Choset 2011 M* Sharon et. al. 2011 ICTS
6. Decoupled Techniques Kant et. al. 1986 Velocity Tuning Erdmann et. al. 1986 Prioritized Planning Silver 2005 (W)HCA* Sturtevant et. al. 2006 Map Abstraction Wang et. al. 2008 Flow Annotation Replanning
7. Suboptimal, Sequential Algorithms with Polynomial Complexity Push Swap 1 3 2 Push Swap 3 1 2 Luna et. al. 2011 Push and Swap Wang et. al. 2011 MAPP; Slideable Khorshid et. al. 2011 TASS Kornhauser et. al. 1984 Pebble Motion
9. From Sequential to Simultaneous Actions   Why do one thing at a time?   Low quality solutions   Inefficient, especially for sparse graphs order Change goal Move to g1 g4 g3 g2 2 1 4 3
11. Push and Swap   Sequential multi-robot path planning   Complete for v-2 agents where v is the number of vertices in the graph   Polynomial complexity   Employs two single robot primitives, Push and Swap to navigate a robot to its goal
12. Push Primitive   Simple, greedy primitive   Moves a robot along a path until blocked   If the blocking robot can be moved, push it! 2 1 3 g1
13. Swap Primitive 1 2 3 4 v   Switches the positions of two adjacent robots   High-level operation: 1.  Push the swapping robots to a vertex v; deg(v) ≥ 3 2.  Free two neighbor vertices of v 3.  Execute a swap 4.  Reverse all actions from steps 1 and 2
14. Swap Primitive 1 2 3 4 v   Switches the positions of two adjacent robots   High-level operation: 1.  Push the swapping robots to a vertex v; deg(v) ≥ 3 2.  Free two neighbor vertices of v 3.  Execute a swap 4.  Reverse all actions from steps 1 and 2
15. Swap Primitive   Switches the positions of two adjacent robots   High-level operation: 1.  Push the swapping robots to a vertex v; deg(v) ≥ 3 2.  Free two neighbor vertices of v 3.  Execute a swap 4.  Reverse all actions from steps 1 and 2 1 2 3 4 v
16. Swap Primitive   Switches the positions of two adjacent robots   High-level operation: 1.  Push the swapping robots to a vertex v; deg(v) ≥ 3 2.  Free two neighbor vertices of v 3.  Execute a swap 4.  Reverse all actions from steps 1 and 2 1 2 3 4 v
17. Push and Swap   For each agent i=1,…,n:   While i not at goal:   While i can push, push as far as possible   If i is not at its goal, Swap Push Swap 1 3 2 Push Swap 3 1 2 g2 g3 g1
18. Attempt at Parallelizing…   While there exists an agent not at its goal:   For each agent i not at its goal:   If i can push, Push   Else, Swap  Why this doesn’t work:  Actions need to respect other agent’s plans  Swap needs to coordinate set of actions over multiple planning periods  Swap cannot reverse steps
19. Solution  Priorities  Handle all swaps before pushes  High level Idea:  Until all the agents are at their goal   During each iteration   Consider in order all swapping agents   Consider in order all pushing agents
20. Push Primitive   “Pushing Agents” in set P   Arbitrary Priority   Agents reserve their new location based on priority   Example – Agent A reserves location 4, preventing agent B from moving there 1 5 2 3 4 6 A B gB gA
21. Swap and Dependency   A failed Push does not imply Swap   Other conditions now cause swap   Check for a “dependency” between two agents gA gB B A gA gB B A Start and goal of B along the shortest path to the goal of agent A. The shortest path of each agent goes through the other.
22. Swap Primitive   Swapping pairs labeled “Swap group” in set S   Groups are prioritized on a first come basis   Swap groups have higher priority than pushing agents 5 6 1 3 3 5 A C gC B v
23. Swap Primitive  v is labeled “swap vertex”; the neighborhood of v is called the “swap area”   Pushing agents cannot push onto the swap area 5 6 1 3 7 5 A C gC B v
24. Swap Primitive   When an agent involved in swap tries to push   A pushing agent – it is pushed   An agent involved in lower priority swap – the swap group is dissolved   An agent involved in higher priority swap – nothing happens 2 7 1 3 4 5 6 8 A gC B C E F v1 v2
25. Swap Primitive   Option 1 – Just push the agent (“clearing agent”) away   Three methods of being pushed   Towards Goal   Towards the goal of previously pushed agents   Towards an empty 2 7 1 3 4 5 6 8 A gC B C
26. Swap Primitive   Option 2   Move the swap group back, and move the clearing agent through the swap vertex   Clearing agent temporarily joins the swap group 4 3 5 6 2 1 B A C 4 3 5 6 2 1 B A C v
28. Example 1 2 3 4 5 6 7 8 9 10 D C A SETS P S U A B C D gD gB gC gA •  Agent B is already at its goal B
29. Example 1 2 3 4 5 6 7 8 9 10 B D C A SETS P S U A C D B gD gB gC gA •  Agent A – Pushes •  Agent B – At Goal •  Agent C – Needs to move past B; swap needed •  Agent D - Pushes
30. Example 1 2 3 4 5 6 7 8 9 10 D C A SETS P S U A D B-C gD gB gC gA •  Agent A – Pushes •  Agent B – Part of swap •  Agent C – Part of swap •  Agent D - Pushes B
31. Example 1 2 3 4 5 6 7 8 9 10 SETS P S U A D B-C gD gB gC gA •  Agent A – Pushes •  Agent B – Part of swap •  Agent C – Part of swap •  Agent D – Needs to wait on agents 2 and 3 A D B C
32. Example 1 2 3 4 5 6 7 8 9 10 SETS P S U D B-C A •  Agent A – Done •  Agent B – Part of swap •  Agent C – Part of swap •  Agent D – Needs to wait on agents B and C B C A D gD gB gC gA
33. Example 1 2 3 4 5 6 7 8 9 10 SETS P S U D B-C A •  Agent A – Done •  Agent B – Pushes C •  Agent D – Pushes A Swap finished! D B C gD gB gC gA
34. Example 1 2 3 4 5 6 7 8 9 10 SETS P S U B C D A •  Agent A – Done •  Agent B – Done •  Agent C – Done •  Agent D – Done A D B C gD gB gC gA
35. Example 1 2 3 4 5 6 7 8 9 10 D C SETS P S U A B C D •  Problem finished B A gD gB gC gA
37. Analysis   Lemma 1: PUSH will not form any new dependencies.   Lemma 2: Only necessary swaps are detected. All dependencies will be resolved if the problem is solvable.   Lemma 3: Pairs of agents will swap at most once on trees.   Theorem: PARALLEL PUSH AND SWAP is complete for trees.
39. Setup   Algorithms evaluated based on path quality, computation time, and success rates.   Comparison of Parallel Push and Swap with:   Sequential Push and Swap   Solution parallelized with post-processing   WHCA*   ODA*   Small-size Benchmarks   Large Scale   Loop   Random Grid   “Moving AI” map from Nathan Sturtevant’s repository
40. Small-size Benchmarks Problems Parallel PS Sequential PS Parallelized Solutions WHCA* (5) ODA* Time Steps Time Steps Time Steps Time Steps Time Steps Tree 1.04 9 0.60 39 3.97 20 0.43 16.1 2.17 6 Corners 2.64 21 1.33 68 29.2 27 0.47 10.2 16.10 8 Tunnel 9.53 44 1.62 159 1574 49 --- --- 184 6 Connect 7.70 37 3.10 126 1167 29 --- --- --- --- String 2.38 15 0.53 39 8.56 23 0.73 14 0.45 8 Double Loop 4527 1015 77.4 5269 --- --- --- --- --- --- Tree Corners Tunnel String Loop/Chain Connector 1 2 3 3 4 1 2 4 3 2 1 3 4 1 2 5 3 1 2 4 6 5 7 2 4 3 1 5 6
41. Large Scale: Loop n-2 agents placed in a loop graph with n vertices
42. Large Scale: Random Grid   20x30 grid map where 20% of cells are obstacles   Populated with 5-100 agents (in increments of 5), 100 random start/goal configurations for each number of agents
46. Arena  Arena map from the game Dragon Age [Sturtevant (2012)]  Populated with 50-200 agents (in increments of 50), 100 random start/ goal configurations for each number of agents
47. Arena
48. Arena
51. Discussion   This work presents an algorithm for multi-agent pathfinding with simultaneous actions   Experimental comparisons show the advantages of the approach both on tightly constrained instances, as well as larger, more general scenarios   Competitive solution lengths, and computation times
52. Future Work   Prove finite number of swaps for general graphs with loops   Relax the restriction requiring two empty vertices in the input graph to guarantee completeness.   Investigate how agent priorities affect computation time and solution quality   Extending Push and Swap to the continuous space   Athanasios Krontiris, Qandeel Sajid, Kostas E Bekris. Towards Using Discrete Multiagent Pathfinding to Address Continuous Problems, Workshops at the Twenty-Sixth AAAI Conference on Artificial Intelligence, 2012