Fault-Tolerant Offline Multi-Agent Path Planning

AAAI-23
https://kei18.github.io/mappcf/

Transcript

1. Fault-Tolerant Offline Multi-Agent Path Planning Keisuke Okumura Tokyo Institute of Technology, Japan ౦ژ޻ۀେֶ 5PLZP
   *OTUJUVUF
   PG
   5FDIOPMPHZ Feb. 7st – 14th, 2023 Washington, DC, USA AAAI-23 https://kei18.github.io/mappcf Sebastien Tixeuil Sorbonne University, CNRS, LIP6, Institut Universitaire de France, France fault solution multiple paths assuming crashes
2. /38 2 Motivation multi-agent path planning (MAPP) is important necessity of building reliable systems cutting-edge studies assume perfect agents robot faults are common => fault-tolerance e.g., mean time between failure of one robot: 125days* *https://fr.autostoresystem.com/benefits/reliable aws.amazon.com path planning where agents may unexpectedly crash at runtime MAPPCF (w/crash faults)
3. /38 3 goal start graph 0 Conventional Solution Concept solution
4. /38 4 1 Conventional Solution Concept
5. /38 5 2 Conventional Solution Concept
6. /38 6 3 Conventional Solution Concept done!
7. /38 7 0 With Unforeseen Crash
8. /38 8 online replanning offline approach: preparing backup paths from the beginning or crash detected => then? 1 With Unforeseen Crash crashed (forever stop)
9. /38 9 primary path Solution Concept of MAPPCF backup path when is detected transition rule & 0
10. /38 10 Solution Concept of MAPPCF 1
11. /38 11 Solution Concept of MAPPCF 2
12. /38 12 Solution Concept of MAPPCF more than two agents may crash => backup path of backup path 3 done!
13. /38 13 Problem Formulation of MAPPCF given solution s.t. all non-crashed agents eventually reach their destination, regardless of crashes (up to f ) & transition rules & maximum number of crashes f defined with failure detector & execution model centralized planning followed by decentralized execution
14. /38 14 Failure Detectors oracle that tells status of neighboring vertices response: 1. no agent query 2. non-crashed agent named FD 3. crashed agent anonymous FD unable to identify who crashes c.f., [Chandra+ JACM-96]
15. /38 15 Execution Models how agents are scheduled at runtime synchronous model all agents act simultaneously solutions avoid collisions MAPF: multi-agent pathfinding [Stern+ SOCS-19] solution solutions avoid deadlocks each agent acts spontaneously while locally avoiding collisions offline time-independent MAPP [Okumura+ IJCAI-22] sequential model (async) solution possible schedule
16. /38 16 Model Power Analyses SYN + AFD SYN + NFD SEQ + NFD SEQ + AFD synchronous model sequential model named failure detector anonymous FD SYN SEQ NFD AFD strictly stronger SEQ+AFD SYN+AFD solvable instances weakly stronger SYN+AFD SYN+NFD SYN+AFD SYN+NFD or solvable in SYN unsolvable in SEQ
17. /38 17 Computational Complexity 1. finding solutions is NP-hard 2. verification is co-NP-complete regardless of FD types or execution models the proofs are reductions from 3-SAT MAPPCF is computationally intractable
18. /38 18 Solving MAPPCF proposal: decoupled crash faults resolution framework (DCRF) synchronous model + named FD number of maximum crashes f =2 example* *DCRF is applicable to other models 1. find initial paths 2. identify unresolved events 3. compute backup path & update solution 4. back to step-2
19. /38 19 How DCRF Solves MAPPCF find initial paths
20. /38 20 How DCRF Solves MAPPCF identify unresolved events unresolved events queue
21. /38 21 How DCRF Solves MAPPCF identify unresolved events unresolved events queue
22. /38 22 How DCRF Solves MAPPCF unresolved events queue identify unresolved events
23. /38 23 How DCRF Solves MAPPCF resolve event
24. /38 24 How DCRF Solves MAPPCF resolve event
25. /38 25 How DCRF Solves MAPPCF update solution
26. /38 26 How DCRF Solves MAPPCF identify unresolved events
27. /38 27 How DCRF Solves MAPPCF resolve event
28. /38 28 How DCRF Solves MAPPCF resolve event
29. /38 29 How DCRF Solves MAPPCF update solution
30. /38 30 How DCRF Solves MAPPCF identify unresolved events
31. /38 31 How DCRF Solves MAPPCF resolve event
32. /38 32 How DCRF Solves MAPPCF resolve event
33. /38 33 How DCRF Solves MAPPCF update solution
34. /38 34 How DCRF Solves MAPPCF identify unresolved events
35. /38 35 How DCRF Solves MAPPCF empty obtain solution DCRF is correct but incomplete unresolved events queue
36. /38 36 Empirical Results         success rate #agents fixed #crashes: f =1 SYN SEQ       success rate #crashes f fixed #agents: 15 SYN SEQ solving MAPPCF becomes difficult with more {agents, crashes} SEQ is harder than SYN random-32-32-10 32x32 (|V|=922) from [Stern+ SOCS-19] 30sec timeout with named FD synchronous SYN v.s. sequential SEQ
37. /38 37 Empirical Results MAPPCF provides better solution concept than finding disjoint paths random-32-32-10 32x32 (|V|=922) from [Stern+ SOCS-19] 30sec timeout with named FD         success rate #agents DCRF/SYN disjoint paths         costs / lower bound #agents DCRF/SYN disjoint paths fixed #crashes: f =1 adapted from CBS [Sharon+ AIJ-15] v.s. finding vertex disjoint paths traveling time when no crashes
38. /38 38 Concluding Remarks MAPPCF novel path planning problem for multiple agents that may crash at runtime fault solution multiple paths assuming crashes https://kei18.github.io/mappcf future directions: complete algorithms, optimization, other types of failure detectors