Anytime search in dynamic graphs Max Likhachev, Dave Ferguson, Geoff Gordon, Anthony Stentz, Sebastian Thrun (2008) Presented by: Eric Andrews Thu 3, October 2013
Outline of presentation Motivation, anytime search, and incremental search 1 Generalization of A* 2 Anytime search algorithm: ARA* 3 Incremental search algorithm: LPA* 4 Anytime and incremental: Anytime D* 5 Example domains and results 6 Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 2 / 39
Realistic planning problems Agents planning and operating in real world. Two problems: ◮ Limited time available for planning = ⇒ producing optimal plans often infeasible. ◮ Model of world imperfect a priori, or world changes while executing plan. ◮ A* alone not good enough! E.g. Autonomous car in traffic trying to get from A to B. Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 3 / 39
Anytime planners: a solution to time limitations Quickly find an initial, highly suboptimal plan. With left over time, try to (iteratively) improve plan. Two desirable traits: ◮ Ability to reuse work of previous iterations. ◮ Controllable bound ( ǫ ) on the suboptimality of the produced plan. One solution: Anytime Repairing A* (ARA*) Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 4 / 39
Incremental planners: a solution to dynamic graphs While executing the plan, we may notice that our model (graph) of the world is no longer in sync with reality. Re-planning after each (minor) change is expensive! Solution: try to reuse as much of previous search efforts as possible. One approach: Lifelong Planning A* (LPA*) Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 5 / 39
Both have downsides... Anytime planners: ◮ Discrepancies in world model = ⇒ new plan from scratch. ◮ Interleaving planning and execution problematic. Incremental planners: ◮ Pre-configured to search for optimal or bounded suboptimal solution. ◮ Can’t improve solution if time left. Novelty of paper: combine both planner types to get Anytime D* (ADA*). ◮ Controllable suboptimality bound. ◮ Allows interleaving. Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 6 / 39
Section 2 Generalization of A* Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 7 / 39
Algorithm 1 A* search ComputePath function. 1: Initialize: g ( s start ) = 0 and for rest of nodes g ( s ) = ∞ . OPEN = { s start } . 2: function ComputePath() while s goal is not expanded do 3: remove s with smallest f ( s ) from OPEN 4: for each successor s ′ of s do 5: if g ( s ′ ) > g ( s ) + c ( s , s ′ ) then 6: g ( s ′ ) = g ( s ) + c ( s , s ′ ) 7: insert/update s ′ in OPEN with f ( s ′ ) = g ( s ′ ) + h ( s ′ ) . 8: end if 9: end for 10: end while 11: 12: end function Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 8 / 39
Naive anytime algorithm using Weighted A* Use inflated heuristics, f ( s ) = g ( s ) + ǫ ∗ h ( s ) , ǫ ≥ 1 ⇒ Bound on returned suboptimal solution is ǫ ! = Series of ComputePath() calls, decrease ǫ in between each. Good: anytime capability, controllable ǫ -suboptimality bound. Bad: duplicate search effort, no reuse. Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 9 / 39
Generalizing A*: v -values New bookkeeping variable along with f and g values. No effect on operation of one-time A*. Allows reuse of search results in subsequent A* runs. Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 10 / 39
Algorithm 2 A* search ComputePath function. 1: Initialize: g ( s start ) = 0 and for rest of nodes g ( s ) = ∞ . v ( s ) = ∞ for all nodes s . OPEN = { s start } . 2: function ComputePath() while s goal is not expanded do 3: remove s with smallest f ( s ) from OPEN 4: v ( s ) = g ( s ) 5: for each successor s ′ of s do 6: if g ( s ′ ) > g ( s ) + c ( s , s ′ ) then 7: g ( s ′ ) = g ( s ) + c ( s , s ′ ) 8: insert/update s ′ in OPEN with f ( s ′ ) = g ( s ′ ) + h ( s ′ ) . 9: end if 10: end for 11: end while 12: 13: end function Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 11 / 39
Inconsistent states A state s is either ◮ inconsistent v ( s ) � = g ( s ) ◮ consistent v ( s ) = g ( s ) Turns out OPEN contains all inconsistent states. So A* expands only inconsistent states. Additionally we have two types of inconsistent states: ◮ Overconsistent v ( s ) > g ( s ) ◮ Underconsistent v ( s ) < g ( s ) (later on) Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 12 / 39
Invariant of A ∗ with v -values For every state s ∈ S : � 0 if s = s start g ( s ) = min s ′ ∈ pred ( s ) ( v ( s ′ ) + c ( s ′ , s )) otherwise Inconsistency is propagated to the children of some state s . Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 13 / 39
Generalizing A*: priority function Good old A* expands states in the order of increasing f -values. Let’s generalize this to any priority function key ( s ) (satisfying certain restrictions...) Goal: restrictions allow the search to gurantee suboptimality bounds even when heuristics are inadmissible! A* with consistent heuristics, and with consistent (constant) inflated heuristics: OK! Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 14 / 39
Restriction For any two states s , s ′ ∈ S s.t. 1 There exists a path from start to goal via s ′ 2 s’ is consistent or overconsistent. 3 s is overconsistent 4 g ( s ′ ) > g ( s ) + ǫ ∗ c ∗ ( s , s ′ ) Then it must hold that key ( s ′ ) > key ( s ) . Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 15 / 39
Section 3 Anytime search algorithm: ARA* Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 16 / 39
Towards Anytime Repairing A* (ARA*) To reuse previous search efforts: make sure that before each execution of ComputePath() , OPEN contains all the inconsistent states. CLOSED set to prevent multiple expansions of same state in single iteration. We now also need INCONS : set of all inconsistent states that are in CLOSED . key ( s ) = g ( s ) + ǫ ∗ h ( s ) Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 17 / 39
Algorithm 3 ARA* search ComputePath function. 1: function ComputePath() while key ( s goal ) > min s ∈ OPEN ( key ( s )) do 2: remove s with smallest key ( s ) from OPEN 3: v ( s ) = g ( s ) ; CLOSED = CLOSED ∪ { s } 4: for each successor s ′ of s do 5: if s ′ was never visited by ARA* before then 6: v ( s ′ ) = g ( s ′ ) = ∞ 7: end if 8: if g ( s ′ ) > g ( s ) + c ( s , s ′ ) then 9: g ( s ′ ) = g ( s ) + c ( s , s ′ ) 10: if s ′ / ∈ CLOSED then 11: insert/update s ′ in OPEN with f ( s ′ ) = g ( s ′ ) + h ( s ′ ) . 12: else 13: insert s ′ into INCONS 14: end if 15: end if 16: end for 17: end while 18: Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 18 / 39
Algorithm 4 ARA main function 1: function Main() g ( s start ) = 0; v ( s start ) = ∞ 2: g ( s goal ) = ∞ ; v ( s goal ) = ∞ 3: OPEN = CLOSED = INCONS = ∅ 4: insert s start into OPEN with key ( s start ) . 5: ComputePath() 6: publish current ǫ -suboptimal solution. 7: while ǫ > 1 do 8: decrease ǫ 9: Move states from INCONS to OPEN 10: Update priorities of states in OPEN according to key 11: CLOSED = ∅ 12: ComputePath(); 13: publish current ǫ -suboptimal solution. 14: end while 15: 16: end function Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 19 / 39
Theoretical properties After ComputePath() exits: for any state s with key ( s ) ≤ min s ′ ∈ OPEN ( key ( s ′ )) , it holds that g ∗ ( s ) ≤ g ( s ) ≤ ǫ ∗ g ∗ ( s ) . ◮ Correctness of ARA* ComptePath() expands a state at most once and only if its v -value is lowered during its expansion. ◮ Computational savings of ARA* Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 20 / 39
ARA* search example Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 21 / 39
Section 4 Incremental search algorithm: LPA* Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 22 / 39
Edge costs can change because of imperfect model or dynamic environment. Edge cost change: update g -value of the node on the incoming side. Decreasing edges? ◮ g only decreases, thus v ( s ) ≥ g ( s ) holds. ◮ No problem for ARA*. Increasing edges? ◮ g increases, thus can happen that v ( s ) < g ( s ) . ◮ Problem for ARA*: doesn’t support underconsistent states! Presented by: Eric Andrews Anytime search in dynamic graphs Thu 3, October 2013 23 / 39
Recommend
More recommend
