CS 460/560 Introduction to Computational Robotics Fall 2017, Rutgers University. Lecture 08 Extras. A* In More Detail. Instructor: Jingjin Yu

Transcription

1 CS 460/560 Introduction to Computational Robotics Fall 2017, Rutgers University Lecture 08 Extras A* In More Detail Instructor: Jingjin Yu

2 Outline A* in more detail Admissible and consistent heuristic Examples Heuristic design Advantage of A* The principle of dynamic programming D* brief introduction

3 Solving Problems through Graph Search x I x G Search for a route in Romania

4 A Generic Graph Search Algorithm input: G = (V, E), x I, x G AddToQueue(x I, Queue); // Add x I to a queue of nodes to be expanded while(!isempty(queue)) x Front(Queue); // Retrieve the front of the queue if(x. expanded == true) continue; x. expanded = true; if(x == x G ) return solution; for each neighbor n i return failure; // Do not expand a node twice // Mark x as expanded // Return if goal is reached of x // Add all neighbors of to the queue if(n i. expanded == false) AddToQueue(n i, Queue) A*: AddToQueue(x) uses f x = g x + h(x) g(x): the current best cost from start node x I to node x h(x): the estimated cost from x to goal x G g(x) is cost-to-come, h(x) is a heuristic The unprocessed node with the smallest f(x) is placed in the front of the queue

5 Admissible and Consistent Heuristic Assume the cheapest path from x to a goal is c(x), an admissible heuristic satisfies h x c(x) A consistent heuristic is defined as h(n) G A form of triangle inequality A consistent heuristic is always admissible The reverse is not always true Example of heuristic functions Manhattan distance Straight-line distance Consistent h n c n, n + h n n c(n, n ) n h(n )

6 A* Search w/ a Consistent Heuristic S 1 4 A 5 2 B 2 C 12 3 G A [1+6] S [f=0+7] B [4+4] State h(x) S 7 A 6 B 4 C 2 G 0 B [3+4] C [6+2] G [13+0] C [5+2] G [8+0]

7 A* Search w/ an Inadmissible Heuristic S 1 4 A 5 2 B 2 C 12 3 G A [1+6] S [f=0+7] B [4+4] State h(x) S 7 A 6 B 4 C 20 G 0 B [3+4] C [6+20] G [13+0] C [5+20] Not optimal! h(x) is inadmissible, e.g., h C = 20 > 3 = c(c), the actual cost from C to G

8 A* Search w/ an Inconsistent Heuristic S 1 4 A 5 2 B 2 C 12 3 G A [1+6] S [f=0+7] B [4+2] State h(x) S 7 A 6 B 2 C 1 G 0 B [3+2] C [6+1] G [13+0] Not optimal! C [6+1] G [9+0] h(x) is inconsistent, e.g., h S > c(s, B) + h(b), h A > c(a, B) + h(b)

9 Heuristic Function Design For route finding problems, Euclidean distance is consistent Also very efficient! Designing heuristic functions can be non-trivial Consider two heuristics for the 8-puzzle h 1 : number of misplaced pieces h 2 : sum of Manhattan distances to goal for all pieces

10 Heuristic Function Design h 1 : #misplaced game pieces = 8 h 2 : sum Manhattan distances = = 18 Both heuristics are admissible and consistent How to choose? Generally, using the largest h is preferred: closer to the actual cost Because h are underestimates In this case, we can use h 2 or simply h = max{h 1, h 2 }

11 Advantage of A* Search Both A* and uniform-cost (i.e., Dijkstra s) are optimal. Why A*? Because A* biases the search toward the goal A* may visit much fewer nodes Similarly, better heuristic smaller explored area x g(x) x I g x + h(x ) x g x h(x ) x G A* explored area Uniform-cost explored area

12 The Principle of Dynamic Programming Dynamic programming is a type of recursion It breaks a big problem into smaller pieces E.g., P n = P n 1 + P(n 2 ) with n = n 1 + n 2 The problem must have structures that allow computation to be reused E.g., for path optimality, any segment of an optimal path must also be optimal x G x 3 x I x 2 Divide-and-conquer search algorithms, e.g., merge-sort, are special cases P n = P(n 1 ) + P(n 2 ) for n 1 = n 2 = n 2 Dijkstra s and A* are also types of dynamic programming x 1

13 D* Algorithm Brief Intro D* and D*-lite stand for dynamic A* Supports previously unknown obstacles Initially, for parts of the environment that is unknown, assume no obstacle Runs A* backwards to find an initial optimal solution Then, execute the path If we hit an obstacle along the way Update the node itself to be unavailable Put all its descendent nodes on the queue for search again Do the above step recursively Restart the A* search to find an optimal path Repeat the previous two steps One may view D* as running many A* searches A new A* search will be run as a previously unknown obstacle is met More details: