1 / 18

Artificial Intelligence

Artificial Intelligence. Search: 2. Ian Gent ipg@cs.st-and.ac.uk. Artificial Intelligence. Search 2. Part I : The Eights Puzzle Part II: Search Algorithms via lists Part II: Best First Search. The Eights Puzzle. Sliding blocks puzzle, more usually 15 puzzle

ernie
Download Presentation

Artificial Intelligence

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. Artificial Intelligence Search: 2 Ian Gent ipg@cs.st-and.ac.uk

  2. Artificial Intelligence Search 2 Part I : The Eights Puzzle Part II: Search Algorithms via lists Part II: Best First Search

  3. The Eights Puzzle • Sliding blocks puzzle, more usually 15 puzzle • shows you the state of AI in the sixties • how many moves between these states?

  4. Search Reminder • Search states, Search trees • Don’t store whole search trees, just the frontier

  5. Frontiers as lists • One way to implement search algorithms is via lists • Lists fundamental in AI programming • main data structure in Lisp, Prolog • makes list processing really easy (no pointers) • <end of advert for AI languages> • Lists can easily store frontier of search • Each element in list is search state • Different algorithms manipulate list differently

  6. A general search algorithm • 1. Form a one element list with null state • 2. Loop Until (either list empty or we have a solution) • Remove the first state X from the list • Choose the next decision to make • e.g. which letter to set in SAT, which city to choose successor in TSP • Create a new state for each possible choice of decision • e.g. upper/lower case, Walla Walla/Oberlin/Ithaca • MERGE the set of new states into the list • different algorithms will have different MERGE methods • 3. If (solution in list) succeed • else list must be empty, so fail

  7. Depth First Search • The most important AI search algorithm? • MERGE = push • treat list as a stack • new search states to explore at front of list, get treated first • What about when many new states created? • We use a heuristic to decide what order to push new states • all new states in front of all old states in the list • What about when no new states created? • We must be at a leaf node in the search tree • we have to backtrack to higher nodes

  8. Breadth First Search • MERGE = add to end • treat list as a queue • new search states to explore at end of list, • What about when many new states created? • We use a heuristic to decide what order to add new states • Breadth first considers all states at a given depth in the search tree before going on to the next depth • compare with depth-first, • depth-first considers all children of current node before any other nodes in the search tree • list can be exponential size -- all nodes at given depth

  9. Depth-First-Depth-Bounded Search • As depth-first search • Disallow nodes beyond a certain depth d in tree • to implement, add depth in tree to search state • Compare DFDB with Depth-first • DFDB: always finds solution at depth <= d • DF may find very deep solution before shallow ones • DFDB: never goes down infinite branch • relevant if search tree contains infinite branches • e.g. Eights puzzle • DFDB: we have a resource limit (b^d if b branching rate) • How do we choose d?

  10. Iterative Deepening Search • No longer a simple instance of general search • d = min-d • Loop Until (solution found) • apply DFDB(d) • d := d + increment • Why? • Guarantees to find a solution if one exists (cf DFDB) • Finds shallow solutions first (cf DF) • Always has small frontier (cf Breadth First) • Surprising asymptotic guarantees • search time typically no more than d/(d-1) as bad as DF

  11. Why is Iterative deepening ok? • Suppose increment = 1, solution at depth d • how much more work do we expect to do in I.D. vs DF ? • I.d. repeats work from depths 1 to d di=1 bi = b d+1 / (b - 1) • Ratio to b d = b d+1 / bd(b - 1) = b/(b-1) • So we only do b/(b-1) times as much work as we need to • e.g. even if b=2, only do twice as much work • Very often worth the overhead for the advantages

  12. Comparing Search Algorithms

  13. Best First Search • All the algorithms up to now have been hard wired • I.e. they search the tree in a fixed order • use heuristics only to choose among a small number of choices • e.g. which letter to set in SAT / whether to be A or a • Would it be a good idea to explore the frontier heuristically? • I.e. use the most promising part of the frontier? • This is Best First Search

  14. Best First Search • Best First Search is still an instance of general algorithm • Need heuristic score for each search state • MERGE: merge new states in sorted order of score • I.e. list always contains most promising state first • can be efficiently done if use (e.g.) heap for list • no, heaps not done for free in Lisp, Prolog. • Search can be like depth-first, breadth-first, or in-between • list can become exponentially long

  15. Search in the Eights Puzzle • The Eights puzzle is different to (e.g.) SAT • can have infinitely long branches if we don’t check for loops • bad news for depth-first, • still ok for iterative deepening • Usually no need to choose variable (e.g. letter in SAT) • there is only one piece to move (the blank) • we have a choice of places to move it to • we might want to minimise length of path • in SAT just want satisfying assignment

  16. Search in the Eights Puzzle • Are the hard wired methods effective? • Breadth-first very poor except for very easy problems • Depth-first useful without loop checking • not much good with it, either • Depth-bounded -- how do we choose depth bound? • Iterative deepening ok • and we can use increment = 2 (why?) • still need good heuristics for move choice • Will Best-First be ok?

  17. Search in the Eights Puzzle • How can we use Best-First for the Eights puzzle? • We need good heuristic for rating states • Ideally want to find guaranteed shortest solution • Therefore need to take account of moves so far • And some way of guaranteeing no better solution elsewhere

  18. Next week in Search for AI • Heuristics for the Eights Puzzle • the A* algorithm

More Related