1 / 25

Search: Optimal

Search: Optimal. Artificial Intelligence CMSC 25000 January, 2002. Agenda. Optimal vs Blind vs Heuristic Search Optimal Search All paths: British Museum procedure Branch & Bound Search Dynamic Programming A* search Problem representation Configuration space. Searches.

adrian-hogan
Télécharger la présentation

Search: Optimal

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Search: Optimal Artificial Intelligence CMSC 25000 January, 2002

  2. Agenda • Optimal vs Blind vs Heuristic Search • Optimal Search • All paths: British Museum procedure • Branch & Bound Search • Dynamic Programming • A* search • Problem representation • Configuration space

  3. Searches • Blind search: Find ANY path to goal • Know nothing: Randomized seach • Know something about search space: • Most paths reach goal or terminate quickly: DFS • Low branching factor, possible long paths: BFS • Heuristic search: Any path, but find faster • Estimate remaining distance to goal • Best from current node: Hill-climbing • Best from any node: Best first • Best w at this depth: Beam search

  4. Optimal Search • Find BEST path to goal • Find best path EFFICIENTLY • Exhaustive search: • Try all paths: return best • Optimal paths with less work: • Expand shortest paths • Expanded shortest expected paths • Eliminate repeated work - dynamic programming

  5. British Museum Procedure • Explore all paths • Return the shortest • Perform DFS or BFS to traverse WHOLE tree • Expensive!!!! • Depth=d; Branching = b: b^d leaf nodes (paths) • Practical only for toy problems

  6. Efficient Optimal Search • Find best path without exploring all paths • Use knowledge about path lengths • Maintain path & path length • Expand shortest paths first • Halt if partial path length > complete path length • Branch & Bound Search

  7. 3 A D 4 7 B 8 9 6 D A E C E E B B F 11 13 11 10 10 12 13 B 15 F 14 G D F 14 16 A C 15 15 Branch and Bound Search S

  8. Branch & Bound Algorithm • Form a 1-element queue of 0 cost=root node • Until first path in queue ends at goal or no paths • Remove 1st path from queue; extend path one step • Reject all paths with loops • Add new paths to queue • Sort all paths by length, shortest first • If goal found=>success; else, failure

  9. Branch & Bound + Underestimates • Improve estimate of complete path length • Add (under)estimate of remaining distance • u(total path dist) = d(partial path)+u(remaining) • Underestimates must ultimately yield shortest • Stop if all u(total path dist) > d(complete path) • Straight-line distance => underestimate • Better estimate => Better search • No missteps • Least info : e(remaining) = 0 - plain B&B

  10. A D 13.4 12.9 A E 19.4 12.9 13 B F 17.7 13 G Branch & Bound w/Underestimates S

  11. Branch & Bound w/UnderestimatesAlgorithm • Form a 1-element queue of 0 cost=root node • Until first path in queue ends at goal or no paths • Remove 1st path from queue; extend path one step • Reject all paths with loops • Add new paths to queue • Sort all paths by total length underestimate, shortest first (d(partial path) + u(remaining)) • If goal found=>success; else, failure

  12. Search with Dynamic Programming • Avoid duplicating work • Dynamic Programming principle: • Shortest path from S to G through I is shortest path from S to I plus shortest path from I to G • No need to consider other routes to or from I

  13. A 3 D 4 B 7 D A 9 E 6 8 X X C E 11 12 B F 11 10 X X G 13 Branch & Bound withDynamic Programming S

  14. Branch & Bound withDynamic Programming • Form a 1-element queue of 0 cost=root node • Until first path in queue ends at goal or no paths • Remove 1st path from queue; extend path one step • Reject all paths with loops • For all paths with same terminal node, keep only shortest • Add new paths to queue • Sort all paths by length, shortest first • If goal found=>success; else, failure

  15. Branch & Bound withDynamic Programming • Avoid searching multiple paths through same intermediate node • Significant savings in effort • 12 nodes vs 21 nodes

  16. A* Search Algorithm • Combines good optimal search ideas • Branch & Bound with dynamic programming and underestimates • Form a 1-element queue of 0 cost=root node • Until first path in queue ends at goal or no paths • Remove 1st path from queue; extend path one step • Reject all paths with loops • For all paths with same terminal node, keep only shortest • Add new paths to queue • Sort all paths by total length underestimate, shortest first (d(partial path) + u(remaining)) • If goal found=>success; else, failure

  17. A E 19.4 12.9 13 B F 17.7 13 G A* Search Example S A D 13.4 12.9

  18. Navigation

  19. Application: Configuration Space • Problem: Robot navigation • Move robot between two objects without changing orientation • Possible? • Complex search space: boundary tests, etc • First step: Problem transformation • Model robot as point • Model obstacles by combining their perimeter + path of robot around it • “Configuration Space”: simpler search

  20. Navigation

  21. Navigation

  22. Navigation as Simple Search • Replace funny robot shape in field of funny shaped obstacles with • Point robot in field of configuration shapes • All movement is: • Start to vertex, vertex to vertex, or vertex to goal • Search: Start, vertexes, goal, & connections • A* search yields efficient least cost path

  23. Summary • Optimal search: • Least cost solution with least work • British Museum procedure • Exhaustive search: report best • Branch & Bound: • Rank options by length; stop when partials>complete • Rank options by underestimate of TOTAL length • Dynamic programming: avoid unnecessary work • A*: B&B + Dynamic Programming + Underest

  24. B&B + DynProg Analysis • Algorithm: • Select best partial path from Q • Test for completion • Add path extensions to Q • Assume that we are using an Expanded “list” to implement Dynamic Prog. (implemented as a hash table – constant access time). Assume we have a graph with N nodes and L links. We call a graph where nodes have O(N) links are dense. Graphs where the nodes have a nearly constant number of links are sparse. For dense graphs L is O(N2). O(N) Paths taken from Q ? O(N) Cost of picking path from Q (& cleanup), using linear scan? O(L) Attempts to add path to Q (many are rejected)? O(1) Cost of adding path extension to front of Q ? O(N2 + L) Total cost ? Lozano-perez, 2000

  25. Search Method Worst Time (Dense) Worst Time (Sparse) Worst Space Guaranteed to find shortest path Branch & Bound A* O(N2) O(N log N) O(N) Yes Cost and Performance Searching a tree with N nodes and L links Searching a tree with branching factor b and depth d L = N= b d+1 Worst case time is proportional to number of nodes visited Worst case space is proportional to maximal length of Q (and Expanded) lozano-perez, 2000

More Related