Se ha denunciado esta presentación.
Utilizamos tu perfil de LinkedIn y tus datos de actividad para personalizar los anuncios y mostrarte publicidad más relevante. Puedes cambiar tus preferencias de publicidad en cualquier momento.

Training at AI Frontiers 2018 - LaiOffer Self-Driving-Car-lecture 2: Incremental Search

84 visualizaciones

Publicado el

LaiOffer Self-Driving-Car-lecture 2: Incremental Search

Publicado en: Tecnología
  • Sé el primero en comentar

  • Sé el primero en recomendar esto

Training at AI Frontiers 2018 - LaiOffer Self-Driving-Car-lecture 2: Incremental Search

  1. 1. INCREMENTAL SEARCH AI Frontiers 2018
  2. 2. PROBLEM STATEMENT Given a potentially inaccurate map of the environment, 
 navigate from S to G
  3. 3. PROBLEM STATEMENT Given a potentially inaccurate map of the environment, 
 navigate from S to G
  4. 4. PROBLEM STATEMENT • Proactive approach: • Take uncertainty into account during planning. Computationally expensive • Reactive approach: • Plan optimistically and replan if necessary. Computationally cheaper
  5. 5. HIGH LEVEL OPERATIONS Case 1: 
 Assume given map is accurate (and the map is accurate)
  6. 6. HIGH LEVEL OPERATIONS 1. Input: Map of the environment 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and go to step 3
  7. 7. HIGH LEVEL OPERATIONS 1. Input: Map of the environment 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and go to step 3
  8. 8. HIGH LEVEL OPERATIONS 1. Input: Map of the environment 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and go to step 3
  9. 9. HIGH LEVEL OPERATIONS 1. Input: Map of the environment 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path If path is blocked, update the map and go to step 3
  10. 10. HIGH LEVEL OPERATIONS 1. Input: Map of the environment 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path If path is blocked, update the map and go to step 3
  11. 11. HIGH LEVEL OPERATIONS 1. Input: Map of the environment 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path If path is blocked, update the map and go to step 3
  12. 12. HIGH LEVEL OPERATIONS 1. Input: Map of the environment 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path If path is blocked, update the map and go to step 3
  13. 13. HIGH LEVEL OPERATIONS Case 2: 
 Assume given map is inaccurate
  14. 14. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and go to step 3
  15. 15. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and go to step 3
  16. 16. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and go to step 3
  17. 17. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  18. 18. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  19. 19. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  20. 20. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  21. 21. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  22. 22. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  23. 23. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  24. 24. HIGH LEVEL OPERATIONS 1. Input: Optimistic map (assume there are no obstacles) 2. Discretize the search space 3. Find a shortest path to the goal 4. Move along path. If path is blocked, update the map and 
 go to step 3
  25. 25. Instead of searching for a shortest path from scratch, reuse information from the previous search to speed up the current search INCREMENTAL SEARCH First search Second search reusing information 
 from the first search ...
  26. 26. INCREMENTAL SEARCH • Generally, there are two classes of algorithms: • Algorithms that improve heuristics: • AA* [Koenig & Likhachev, AAMAS ’05] • MT-AA* [Koenig, Likhachev & Sun, AAMAS ’07] • GAA* [Sun, Koenig &Yeoh, AAMAS ’08] • ... • Algorithms that transform search trees: • G-FRA* [Sun,Yeoh & Koenig, AAMAS ’10] • FRA* [Sun,Yeoh & Koenig, IJCAI ’09] • ...
  27. 27. INCREMENTAL SEARCH • Generally, there are two classes of algorithms: • Algorithms that improve heuristics: • AA* [Koenig & Likhachev, AAMAS ’05] • MT-AA* [Koenig, Likhachev & Sun, AAMAS ’07] • GAA* [Sun, Koenig &Yeoh, AAMAS ’08] • ... • Algorithms that transform search trees: • G-FRA* [Sun,Yeoh & Koenig, AAMAS ’10] • FRA* [Sun,Yeoh & Koenig, IJCAI ’09] • ...
  28. 28. BACKGROUND: A* • Maintains three values for each cell s • g(s): cost from start to s • h(s): estimated cost from s to goal • f(s) = g(s) + h(s): estimated cost from start to goal • Maintains two lists • CLOSED: Contains expanded cells (i.e., cells whose shortest path from start is known) • OPEN: Priority queue that contains generated cells
  29. 29. BACKGROUND: A* 1 5
 2 1 6
 2 0 7
 6 1 8
 2 1 4
 2 1 5
 2 1 6
 2 1 7
 2 1 4
 2 1 5
 2 1 6
 2 1 2
 2 1 3
 2 1 4
 2 1 5
 2 1 1
 2 1 2
 2 1 3
 2 1 4
 2 1 4
 2 1 3
 2 0 2
 2 S 1 0
 2 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  30. 30. BACKGROUND: A* 1 5
 2 1 6
 2 0 7
 6 1 8
 2 1 4
 2 1 5
 2 1 6
 2 1 7
 2 1 4
 2 1 5
 2 1 6
 2 1 2
 2 1 3
 2 1 4
 2 1 5
 2 1 1
 2 1 2
 2 1 3
 2 1 4
 2 1 4
 2 1 3
 4 0 2
 2 S 1 0
 2 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  31. 31. BACKGROUND: A* 1 5
 2 1 6
 2 0 7
 6 1 8
 2 2 4
 6 1 5
 2 1 6
 2 1 7
 2 1 4
 2 1 5
 2 1 6
 2 1 2
 2 1 3
 2 1 4
 2 1 5
 2 1 1
 2 1 2
 2 1 3
 2 1 4
 2 2 4
 6 1 3
 4 0 2
 2 S 1 0
 2 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  32. 32. BACKGROUND: A* 3 5
 8 1 6
 2 0 7
 6 1 8
 2 2 4
 6 3 5
 8 1 6
 2 1 7
 2 1 4
 2 1 5
 2 1 6
 2 1 2
 2 1 3
 2 1 4
 2 1 5
 2 1 1
 2 1 2
 2 1 3
 2 1 4
 2 2 4
 6 1 3
 4 0 2
 2 S 1 0
 2 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  33. 33. BACKGROUND: A* 3 5
 8 4 6
 10 0 7
 6 1 8
 2 2 4
 6 3 5
 8 4 6
 10 1 7
 2 4 4
 8 5 5
 10 1 6
 2 6 2
 8 5 3
 8 6 4
 10 1 5
 2 7 1
 8 6 2
 8 7 3
 10 1 4
 2 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  34. 34. BACKGROUND: A* 3 5
 8 4 6
 10 0 7
 6 1 8
 2 2 4
 6 3 5
 8 4 6
 10 1 7
 2 4 4
 8 5 5
 10 1 6
 2 6 2
 8 5 3
 8 6 4
 10 1 5
 2 7 1
 8 6 2
 8 7 3
 10 1 4
 2 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  35. 35. INCREMENTAL SEARCH • Generally, there are two classes of algorithms: • Algorithms that improve heuristics: • AA* [Koenig & Likhachev, AAMAS ’05] • MT-AA* [Koenig, Likhachev & Sun, AAMAS ’07] • GAA* [Sun, Koenig &Yeoh, AAMAS ’08] • ... • Algorithms that transform search trees: • G-FRA* [Sun,Yeoh & Koenig, AAMAS ’10] • FRA* [Sun,Yeoh & Koenig, IJCAI ’09] • ...
  36. 36. ALGORITHM 1: AA* • Adaptive A* (AA*) [Koenig & Likhachev, AAMAS ’05] • Uses standard A* searches • Updates h-values to make them more informed, i.e. better estimates • Speeds up the A* searches
  37. 37. ALGORITHM 1: AA* Main idea: g(s) + cost(s, goal) ≥ g(goal)
 cost(s,goal) ≥ g(goal) - g(s)
 hnew(s) = g(goal) - g(s) s goalstart g(goal) cost(s,goal)g(s)
  38. 38. ALGORITHM 1: AA* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  39. 39. ALGORITHM 1: AA* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  40. 40. ALGORITHM 1: AA* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  41. 41. ALGORITHM 1: AA* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  42. 42. ALGORITHM 1: AA* 2 5
 7 1 6
 7 2 7
 9 1 4
 5 0 5
 5 S 1 6
 7 2 7
 9 2 5
 7 3 6
 9 7 2
 9 4 3
 7 3 4
 7 4 5
 9 6 1
 7 5 2
 7 4 3
 7 5 4
 9 3 4
 7 2 3
 5 3 2
 5 7 0
 7 G 1 2 3 4 5 6 7 2 5
 7 1 6
 7 2 7
 9 1 6
 7 0 5
 5 S 1 6
 7 2 7
 9 2 5
 7 3 6
 9 7 2
 9 4 3
 7 3 4
 7 4 5
 9 6 1
 7 5 2
 7 4 3
 7 5 4
 9 3 6
 9 2 7
 9 7 0
 7 G A E D C B G F 1 2 3 4 5 6 7 Adaptive A* A*
  43. 43. ALGORITHM 1: AA* • Results: • Up to 20% faster than A* on grids with Manhattan distance as h-values • Typically, the worse the h-values, the larger the speedup • Well-suited for high dimensional search spaces, where h-values are often bad
  44. 44. ALGORITHM 1: AA* Other algorithms in this class: • MT-AA* [Koenig, Likhachev & Sun, AAMAS ’07] • Extension to search paths when the target moves • GAA* [Sun, Koenig &Yeoh, AAMAS ’08] • Extension to handle decreasing costs • Applied to control the robotic arm at the International Space Station by the Canadian Space Agency [Belghith, Kabanza & Hartman, AIS ’10] • Trea-AA* [Hernandez, Sun, Koenig & Meseguer, AAMAS ’11] • Extension to speed up the search by reusing search trees
  45. 45. INCREMENTAL SEARCH • Generally, there are two classes of algorithms: • Algorithms that improve heuristics: • AA* [Koenig & Likhachev, AAMAS ’05] • MT-AA* [Koenig, Likhachev & Sun, AAMAS ’07] • GAA* [Sun, Koenig &Yeoh, AAMAS ’08] • ... • Algorithms that transform search trees: • G-FRA* [Sun,Yeoh & Koenig, AAMAS ’10] • FRA* [Sun,Yeoh & Koenig, IJCAI ’09] • ...
  46. 46. ALGORITHM 2: G-FRA* • Generalized Fringe-Retrieving A* (G-FRA*) 
 [Sun,Yeoh & Koenig, AAMAS ’08] • Uses standard A* searches • Identifies portions of the search tree of the previous search that can be reused • Starts the search with these portions
  47. 47. BACKGROUND: A* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  48. 48. BACKGROUND: A* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  49. 49. BACKGROUND: A* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 8 G while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  50. 50. BACKGROUND: A* 3 5
 8 4 6
 10 2 4
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 2 4
 6 1 3
 4 0 2
 2 S 8 0
 0 G C3 C4 D2 D3 D4 E3 F2 F3 F4 C6 D6 E6 F6 C5 D5 E5E2 while(goal ∉ CLOSED) { s = argmins∈OPEN f(s) move s to CLOSED for all neighboring cells c of s { if(c ∉ OPEN ∪ CLOSED) set g(c) and f(c) add c to OPEN else if(c ∈ OPEN) update g(c) and f(c) } } A E D C B G F 1 2 3 4 5 6 7 g h
 f f = g + h CLOSEDOPEN parent pointers
  51. 51. C3 C4 D2 D3 D4 E2 E3 F2 F3 F4 C6 D6 E6 F6 C5 D5 E5
  52. 52. C3 C4 D2 D3 D4 E2 E3F2 F3 F4 C6 D6 E6 F6 C5 D5 E5
  53. 53. C3 C4 D2 D3 D4 E2 E3F2 F3 F4 C6 D6 E6 F6 C5 D5 E5
  54. 54. C3 C4 D2 D3 D4 E2 E3 F2 F3 F4 C6 D6 E6 F6 C5 D5 E5
  55. 55. ALGORITHM 2: G-FRA* 4 6
 10 0 7
 6 1 8
 2 3 5
 8 4 6
 10 1 7
 2 4 4
 8 5 5
 10 1 6
 2 6 2
 8 5 3
 8 6 4
 10 1 5
 2 7 1
 8 6 2
 8 7 3
 10 1 4
 2 8 0
 0 G A E D C B G F 1 2 3 4 5 6 7 C3 C4 D2 D3 D4 E2 E3 F2 F3 F4 C6 D6 E6 F6 C5 D5 E5 High-level pseudocode: 1. Identify reusable portion of the search tree 2. Remove the unreusable portion 3. Add the cells in the fringe to the OPEN list 4. Restart the search
  56. 56. ALGORITHM 2: G-FRA* 0 7
 6 4 6
 10 0 7
 6 0 7
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 0 7
 6 0 7
 6 0 7
 6 8 0
 0 G C3 C4 D2 D3 D4 C6 D6 E6 F6 C5 D5 E5 A E D C B G F 1 2 3 4 5 6 7 High-level pseudocode: 1. Identify reusable portion of the search tree 2. Remove the unreusable portion
  57. 57. ALGORITHM 2: G-FRA* 0 7
 6 4 6
 10 0 7
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 0 7
 6 0 7
 6 0 7
 6 8 0
 0 G C3 C4 D2 D3 D4 C6 D6 E6 F6 C5 D5 E5E3 A E D C B G F 1 2 3 4 5 6 7 High-level pseudocode: 1. Identify reusable portion of the search tree 2. Remove the unreusable portion 3. Add the cells in the fringe to the OPEN list
  58. 58. ALGORITHM 2: G-FRA* 0 7
 6 4 6
 10 0 7
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 0 7
 6 0 7
 6 0 7
 6 8 0
 0 G C3 C4 D2 D3 D4 C6 D6 E6 F6 C5 D5 E5 High-level pseudocode: 1. Identify reusable portion of the search tree 2. Remove the unreusable portion 3. Add the cells in the fringe to the OPEN list 4. Restart the search E3 A E D C B G F 1 2 3 4 5 6 7
  59. 59. ALGORITHM 2: G-FRA* 0 7
 6 4 6
 10 0 7
 6 3 5
 8 4 6
 10 4 4
 8 5 5
 10 6 2
 8 5 3
 8 6 4
 10 7 1
 8 6 2
 8 7 3
 10 0 7
 6 0 7
 6 0 7
 6 8 0
 0 G C3 C4 D2 D3 D4 C6 D6 E6 F6 C5 D5 E5E3 A E D C B G F 1 2 3 4 5 6 7 High-level pseudocode: 1. Identify reusable portion of the search tree 2. Remove the unreusable portion 3. Add the cells in the fringe to the OPEN list 4. Restart the search
  60. 60. ALGORITHM 2: G-FRA* • Results: • Up to one order of magnitude faster than GAA* • Typically, the larger the reusable portion of the search tree, the faster the algorithm • Well suited for problems that change only slightly between search iterations
  61. 61. ALGORITHM 2: G-FRA* Other algorithms in this class: • FRA* [Sun,Yeoh & Koenig, IJCAI ’07] • Optimized version of G-FRA* for navigation in 2D grids • D* [Stentz, ICRA ’94], D* Lite [Koenig & Likhachev, AAAI ’02] • Applied to the navigation of the Mars rovers • Applied to the navigation of UGVs in the DARPA Urban Challenge • MT-D* Lite [Sun,Yeoh & Koenig, AAMAS ’10] • Combination of D* Lite and G-FRA* to speed up the search
  62. 62. SUMMARY • Incremental search algorithms • Reuses information to speed up the search • Useful when one needs to search repeatedly for shortest paths in a graph • Often applied to robotics applications for autonomous navigation

×