Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Fault-Tolerant Offline Multi-Agent Path Planning

Fault-Tolerant Offline Multi-Agent Path Planning

More Decks by Keisuke Okumura | 奥村圭祐

Other Decks in Research


  1. Fault-Tolerant Offline Multi-Agent Path Planning Keisuke Okumura Tokyo Institute of

    Technology, Japan ౦ژ޻ۀେֶ 5PLZP*OTUJUVUFPG5FDIOPMPHZ 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 8 online replanning offline approach: preparing backup paths from

    the beginning or crash detected => then? 1 With Unforeseen Crash crashed (forever stop)
  4. /38 9 primary path Solution Concept of MAPPCF backup path

    when is detected transition rule & 0
  5. /38 12 Solution Concept of MAPPCF more than two agents

    may crash => backup path of backup path 3 done!
  6. /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
  7. /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]
  8. /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
  9. /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
  10. /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
  11. /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
  12. /38 35 How DCRF Solves MAPPCF empty obtain solution DCRF

    is correct but incomplete unresolved events queue
  13. /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
  14. /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
  15. /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