Uninformed Search. Models To Be Studied in CS 540. Chapter Search Example: Route Finding

Transcription

1 Models To e tudied in 50 Uninformed earch hapter tate-based Models Model task as a graph of all possible states l alled a state-space graph state captures all the relevant information about the past in order to act (optimally) in the future ctions correspond to transitions from one state to another olutions are defined as a sequence of steps/actions (i.e., a path in the graph) Many I (and non-i) Tasks can be ormulated as earch Problems earch xample: Route inding oal is to find a sequence of actions l Puzzles l ames l Navigation l ssignment l Motion planning l cheduling l Routing ctions: go straight, turn left, turn right oal: shortest? fastest? most scenic?

2 earch xample: River rossing Problem earch xample: 8-Puzzle Rules: ) armer must row the boat 2) Only room for one other 3) Without the farmer present: og bites sheep heep eats cabbage oal: ll on right side of river ctions: >, <, >, <, >, <, >, < ctions: move tiles (e.g., Move2own) oal: reach a certain configuration earch xample: Water Jugs Problem earch xample: Robot Motion Planning iven -liter and 3-liter pitchers, how do you get exactly 2 liters into the -liter pitcher? ctions: translate and rotate joints oal: fastest? most energy efficient? safest? 3 2

3 earch xample: Natural Language Translation earch xample: 8-Queens Italian à nglish: la casa blu à the blue house ctions: translate single words (e.g., la à the) oal: fluent nglish? preserves meaning? earch xample: Remove 5 ticks Problem asic earch Task ssumptions (usually, though not games) Remove exactly 5 of the sticks so the resulting figure forms exactly 3 squares l ully observable l eterministic l tatic l iscrete l ingle agent l olution is a sequence of actions 3

4 What Knowledge does the gent Need? ow should the nvironment be Represented? l The information needs to be sufficient to describe all relevant aspects for reaching the adequate to describe the world state / situation l ully observable assumption, also known as the closed world assumption, means ll necessary information about a problem domain is accessible so that each state is a complete description of the world; there is no missing information at any point in time 5 l Knowledge representation problem: What information from the sensors is relevant? ow to represent domain knowledge? l etermining what to represent is difficult and is usually left to the system designer to specify l Problem tate = representation of all necessary information about the environment l tate pace (aka Problem pace) = all possible valid configurations of the environment What oal does the gent want to chieve? What ctions does the gent Need? l ow do you describe the? as a task to be accomplished as a state to be reached as a set of properties to be satisfied l ow do you know when the is reached? with a test that defines what it means to have achieved/satisfied the or, with a set of states l etermining the is usually left to the system designer or user to specify l iscrete and eterministic task assumptions imply l iven: an action (aka operator or move) a description of the current state of the world l ction completely specifies: if that action can be applied (i.e., legal) what the exact state of the world will be after the action is performed in the current state (no "history" information needed to compute the successor state)

5 What ctions does the gent Need? earch xample: 8-Puzzle l finite set of actions/operators needs to be decomposed into atomic steps that are discrete and indivisible, and therefore can be treated as instantaneous sufficient to describe all necessary changes l The number of actions needed depends on how the world states are represented l tates = configurations l ctions = up to kinds of moves: up, down, left, right 8 Water Jugs Problem iven -liter and 3-liter pitchers, how do you get exactly 2 liters into the -liter pitcher? 3 tate: (x, y) for # liters in -liter and 3-liter pitchers, respectively ctions: empty, fill, pour water between pitchers Initial state: (0, 0) oal state: (2, *) ction / uccessor unctions. (x, y x < ) (, y) ill 2. (x, y y < 3) (x, 3) ill 3 3. (x, y x > 0) (0, y) mpty. (x, y y > 0) (x, 0) mpty 3 5. (x, y x+y and y > 0) (, y - ( - x)) Pour from 3 to until is full. (x, y x+y 3 and x > 0) (x - (3 - y), 3). (x, y x+y and y > 0) (x+y, 0) Pour from to 3 until 3 is full Pour all water from 3 to 5

6 ormalizing earch in a tate pace l state space is a directed graph: (V, ) V is a set of nodes (vertices) is a set of arcs (edges) each arc is directed from one node to another node l ach node is a data structure that contains: a state description other information such as: l link to parent node l name of action that generated this node (from its parent) l other bookkeeping data ormalizing earch in a tate pace l ach arc corresponds to one of the finite number of actions: when the action is applied to the state associated with the arc's source node then the resulting state is the state associated with the arc's destination node l ach arc has a fixed, positive cost: corresponds to the cost of the action ormalizing earch in a tate pace ormalizing earch in a tate pace l ach node has a finite set of successor nodes: corresponds to all of the legal actions that can be applied at the source node's state l xpanding a node means: generate all of the successor nodes add them and their associated arcs to the statespace search tree l One or more nodes are designated as nodes l test is applied to a node's state to determine if it is a node l solution is a sequence of actions associated with a path in the state space from a to a node: just the state (e.g., cryptarithmetic) a path from to state (e.g., 8-puzzle) l The cost of a solution is the sum of the arc costs on the solution path 2 25

7 earch ummary olution is an ordered sequence of primitive actions (steps) f(x) = a, a 2,, a n where x is the input Model task as a graph of all possible states and actions, and a solution as a path state captures all the relevant information about the past izes of tate paces* Problem # Nodes l Tic-Tac-Toe 0 3 l heckers 0 20 l hess 0 50 l o 0 0 * pproximate number of legal states What are the omponents of ormalizing earch in a tate pace? ormalizing earch search problem has five components:, I,, actions, cost. tate space : all valid configurations? 2. Initial states I : a set of states 3. oal states : a set of states. n action function successors(s) : states reachable in one step (one arc) from s I = {(,)} = {(,)} successors((,)) = {(,)} successors((,)) = {(,), (,), (,)} 5. cost function cost(s, s ): The cost of moving from s to s l The of search is to find a solution path from a state in I to a state in

8 tate pace = irected raph,, ifferent earch trategies l The generated, but not yet expanded, states define the rontier (aka Open or ringe) set l The essential difference is, which state in the rontier to expand next?,,,,,,,, tart,, oal,,,,,, l In general, there will be many generated, but unexpanded, states at any given time during a search l One has to choose which one to expand next tart,, oal 33 ormalizing earch in a tate pace tate-space search is the process of searching through a state space for a solution by making explicit a sufficient portion of an implicit state-space graph, in the form of a search tree, to include a node: TR R lgorithm: rontier = {}, where is the node Loop do called expanding node n if rontier is empty then return failure pick a node, n, from rontier if n is a node then return solution enerate all n s successor nodes and add them all to rontier Remove n from rontier 3 ormalizing earch in a tate pace l This algorithm does NOT detect when node is generated l This algorithm does NOT detect loops (i.e., repeated states) in state space l ach node implicitly represents a partial solution path from the node to the given node cost of the partial solution path l rom this node there may be many possible paths that have this partial path as a prefix many possible solutions 8

9 tate pace raph Uninformed earch on Trees b a c t OL l Uninformed means we only know: The test The successors() function TRT p d q e h u r f l l ut not which non- states are better or now, also assume state space is a tree That is, we won t worry about repeated states We will relax this later What is the corresponding search tree? v Key Issues of tate-pace earch lgorithm l earch process constructs a "search tree" root is the state leaf nodes are: l unexpanded nodes (in the rontier list) l "dead ends" (nodes that aren't s and have no successors because no operators were applicable) l node is last leaf node found l Loops in graph may cause "search tree" to be infinite even if state space is small l hanging the rontier ordering leads to different search strategies 8-Puzzle tate-pace earch Tree (Not all nodes shown; e.g., no backwards moves) 3

10 Uninformed earch trategies Uninformed earch: strategies that order nodes without using any domain specific information, i.e., don t use any information stored in a state readth-irst earch () xpand the shallowest node first:. xamine states one step away from the initial states 2. xamine states two steps away from the initial states 3. and so on l : breadth-first search Queue (IO) used for the rontier remove from front, add to back 5 l : depth-first search tack (LIO) used for the rontier remove from front, add to front oal readth-irst earch () readth-irst earch () generalearch(problem, queue) # of nodes tested: 0, expanded: 0 expnd. node rontier list {} generalearch(problem, queue) # of nodes tested:, expanded: expnd. node rontier list {} not {,,}

11 readth-irst earch () readth-irst earch () generalearch(problem, queue) # of nodes tested: 2, expanded: 2 expnd. node rontier list {} {,,} not {,,,} 2 generalearch(problem, queue) # of nodes tested: 3, expanded: 3 expnd. node rontier list {} {,,} {,,,} not {,,,} 2 50 readth-irst earch () readth-irst earch () generalearch(problem, queue) # of nodes tested:, expanded: expnd. node rontier list {} {,,} {,,,} {,,,} not {,,,} 2 generalearch(problem, queue) # of nodes tested: 5, expanded: 5 expnd. node rontier list {} {,,} {,,,} {,,,} {,,,} not {,,,}

12 readth-irst earch () readth-irst earch () generalearch(problem, queue) # of nodes tested:, expanded: expnd. node rontier list {} {,,} {,,,} {,,,} {,,,} {,,,} not {,,,} 2 generalearch(problem, queue) # of nodes tested:, expanded: expnd. node rontier list {} {,,} {,,,} {,,,} {,,,} {,,,} {,,,} {,,} no expand readth-irst earch () valuating earch trategies 55 generalearch(problem, queue) # of nodes tested:, expanded: expnd. node rontier list {} {,,} {,,,} {,,,} {,,,} {,,,} {,,,} {,,} path:,, cost: l ompleteness If a solution exists, will it be found? a complete algorithm will find a solution (not all) l Optimality / dmissibility If a solution is found, is it guaranteed to be optimal? an admissible algorithm will find a solution with minimum cost 2

13 valuating earch trategies l Time omplexity ow long does it take to find a solution? usually measured for worst case measured by counting number of nodes expanded l pace omplexity ow much space is used by the algorithm? measured in terms of the maximum size of the rontier during the search What s in the rontier for? l If is at depth d, how big is the rontier (worst case)? oal 58 readth-irst earch () readth-irst earch () l omplete l Optimal / dmissible Yes, if all operators (i.e., arcs) have the same constant cost, or costs are positive, non-decreasing with depth otherwise, not optimal but does guarantee finding solution of shortest length (i.e., fewest arcs) l Time and space complexity: O(b d ) (i.e., exponential) d is the depth of the solution b is the branching factor at each non-leaf node l Very slow to find solutions with a large number of steps because must look at all shorter length possibilities first 0 3

14 readth-irst earch () Problem: iven tate pace l complete search tree has a total # of nodes = + b + b b d = (b (d+) - ) / (b-) d: the tree's depth b: the branching factor at each non-leaf node l or example: d = 2, b = = (0 3 - )/ = O(0 2 ) If expands,000 nodes/sec and each node uses 00 bytes of storage, then will take 35 years to run in the worst case, and it will use terabytes of memory! 2 l ssume child nodes visited in increasing alphabetical order epth-irst earch xpand the deepest node first. elect a direction, go deep to the end 2. lightly change the end 3. lightly change the end some more Use a tack to order nodes on the rontier l =? oal

15 epth-irst earch () epth-irst earch () generalearch(problem, stack) # of nodes tested: 0, expanded: 0 expnd. node rontier {} generalearch(problem, stack) # of nodes tested:, expanded: expnd. node rontier {} not {,,} epth-irst earch () epth-irst earch () generalearch(problem, stack) # of nodes tested: 2, expanded: 2 expnd. node rontier {} {,,} not {,,,} 2 generalearch(problem, stack) # of nodes tested: 3, expanded: 3 expnd. node rontier {} {,,} {,,,} not {,,,} 2 0 5

16 epth-irst earch () epth-irst earch () generalearch(problem, stack) # of nodes tested:, expanded: expnd. node rontier {} {,,} {,,,} {,,,} not {,,} 2 generalearch(problem, stack) # of nodes tested: 5, expanded: 5 expnd. node rontier {} {,,} {,,,} {,,,} {,,} not {,,} 2 2 epth-irst earch () epth-irst earch () 3 generalearch(problem, stack) # of nodes tested:, expanded: 5 expnd. node rontier {} {,,} {,,,} {,,,} {,,} {,,} {,} no expand 2 generalearch(problem, stack) # of nodes tested:, expanded: 5 expnd. node rontier {} {,,} {,,,} {,,,} {,,} {,,} {,} 2 path:,,, cost: 5

17 Problem: iven tate pace l ssume child nodes visited in increasing alphabetical order l o ycle hecking: on t add node to rontier if its state already occurs on path back to root l =? epth-irst earch () epth-irst earch () l May not terminate without a depth bound i.e., cutting off search below a fixed depth, l Not complete with or without cycle detection and, with or without a depth cutoff l Not optimal / admissible l an find long solutions quickly if lucky l Time complexity: O(b d ) exponential pace complexity: O(bd) linear d is the depth of the solution b is the branching factor at each non-leaf node l Performs chronological backtracking i.e., when search hits a dead end, backs up one level at a time problematic if the mistake occurs because of a bad action choice near the top of search tree 8

18 Uniform-ost earch (U) Uniform-ost earch (U) l Use a Priority Queue to order nodes on the rontier list, sorted by path cost l Let g(n) = cost of path from node s to current node n l ort nodes by increasing value of g generalearch(problem, priorityqueue) # of nodes tested: 0, expanded: 0 expnd. node rontier list {} 2 80 Uniform-ost earch (U) Uniform-ost earch (U) generalearch(problem, priorityqueue) # of nodes tested:, expanded: expnd. node rontier list {:0} not {:2,:,:5} generalearch(problem, priorityqueue) # of nodes tested: 2, expanded: 2 expnd. node rontier list {} {:2,:,:5} not {:,:5,:2+}

19 Uniform-ost earch (U) Uniform-ost earch (U) generalearch(problem, priorityqueue) # of nodes tested: 3, expanded: 3 expnd. node rontier list {} {:2,:,:5} {:,:5,:8} not {:5,:+2,:8} 2 generalearch(problem, priorityqueue) # of nodes tested:, expanded: expnd. node rontier list {} {:2,:,:5} {:,:5,:8} {:5,:,:8} not {:,:8,:5+, :5+} Uniform-ost earch (U) Uniform-ost earch (U) generalearch(problem, priorityqueue) # of nodes tested: 5, expanded: 5 expnd. node rontier list {} {:2,:,:5} {:,:5,:8} {:5,:,:8} {:,:8,:,:} not {:+2+,:8,:, :} 2 generalearch(problem, priorityqueue) # of nodes tested:, expanded: 5 expnd. node rontier list {} {:2,:,:5} {:,:5,:8} {:5,:,:8} {:,:8,:,:} {:,:8,:,:} {:8,:,:} no expand

20 Uniform-ost earch (U) Problem: iven tate pace 8 generalearch(problem, priorityqueue) # of nodes tested:, expanded: 5 expnd. node rontier list {} {:2,:,:5} {:,:5,:8} {:5,:,:8} {:,:8,:,:} {:,:8,:,:} {:8,:,:} 2 path:,,, cost: Uniform-ost earch (U) l ssume child nodes visited in increasing alphabetical order l U =? l alled ijkstra's lgorithm in the algorithms literature l imilar to ranch and ound lgorithm in Operations Research literature l omplete l Optimal / dmissible requires that the test is done when a node is removed from the rontier rather than when the node is generated by its parent node 0 20

21 Uniform-ost earch (U) Iterative-eepening earch (I) l Time and space complexity: O(b d ) (i.e., exponential) d is the depth of the solution b is the branching factor at each non-leaf node l More precisely, time and space complexity is O(b */ε ) where all edge costs > 0, and * is the best path cost l requires modification to search algorithm: do to depth and treat all children of the node as leaves if no solution found, do to depth 2 repeat by increasing depth bound until a solution found l tart node is at depth 0 2 Iterative-eepening earch (I) Iterative-eepening earch (I) deepeningearch(problem) depth:, # of nodes expanded: 0, tested: 0 expnd. node rontier {} deepeningearch(problem) depth:, # of nodes tested:, expanded: expnd. node rontier {} not {,,}

22 Iterative-eepening earch (I) Iterative-eepening earch (I) deepeningearch(problem) depth:, # of nodes tested: 2, expanded: expnd. node rontier {} {,,} not {,} no expand 2 deepeningearch(problem) depth:, # of nodes tested: 3, expanded: expnd. node rontier {} {,,} {,} not {} no expand 2 Iterative-eepening earch (I) Iterative-eepening earch (I) deepeningearch(problem) depth:, # of nodes tested:, expanded: expnd. node rontier {} {,,} {,} {} not { } no expand-il 2 deepeningearch(problem) depth: 2, # of nodes tested: (), expanded: 2 expnd. node rontier {} {,,} {,} {} { } no test {,,}

23 Iterative-eepening earch (I) Iterative-eepening earch (I) deepeningearch(problem) depth: 2, # of nodes tested: (2), expanded: 3 expnd. node rontier {} {,,} {,} {} { } {,,} no test {,,,} 2 deepeningearch(problem) depth: 2, # of nodes tested: 5(2), expanded: 3 expnd. node rontier {} {,,} {,} {} { } {,,} {,,,} not {,,} no expand Iterative-eepening earch (I) Iterative-eepening earch (I) 0 2 deepeningearch(problem) depth: 2, # of nodes tested: (2), expanded: 3 expnd. node rontier {} {,,} {,} {} { } {,,} {,,,} {,,} not {,} no expand deepeningearch(problem) depth: 2, # of nodes tested: (3), expanded: expnd. node rontier {} {,,} {,} {} { } {,,} {,,,} {,,} {,} no test {,} 2 23

24 Iterative-eepening earch (I) Iterative-eepening earch (I) 0 deepeningearch(problem) depth: 2, # of nodes tested: (3), expanded: expnd. node rontier {} {,,} {,} {} { } {,,} {,,,} {,,} {,} {,} {} no expand deepeningearch(problem) depth: 2, # of nodes tested: (3), expanded: expnd. node rontier {} {,,} {,} {} { } {,,} {,,,} {,,} {,} {,} {} path:,, cost: 8 2 Iterative-eepening earch (I) l as advantages of completeness optimality as stated for l as advantages of limited space in practice, even with redundant effort it still finds longer paths more quickly than Iterative-eepening earch (I) l pace complexity: O(bd) (i.e., linear like ) l Time complexity is a little worse than or because nodes near the top of the search tree are generated multiple times (redundant effort) l Worst case time complexity: O(b d ) exponential because most nodes are near the bottom of tree 0 0 2

25 0 8 Iterative-eepening earch (I) ow much redundant effort is done? l The number of times the nodes are generated: b d + 2b (d-) db b d / ( /b) 2 = O(b d ) d: the solution's depth b: the branching factor at each non-leaf node l or example: b = d / ( ¼) 2 = d / (.5) 2 =.8 d in the worst case, 8% more nodes are searched (redundant effort) than exist at depth d as b increases, this % decreases Iterative-eepening earch l Trades a little time for a huge reduction in space lets you do breadth-first search with (more space efficient) depth-first search l nytime algorithm: good for response-time critical applications, e.g., games l n anytime algorithm is an algorithm that can return a valid solution to a problem even if it's interrupted at any time before it ends. The algorithm is expected to find better and better solutions the longer it runs. idirectional earch l readth-first search from both and l top when rontiers meet l enerates O(b d/2 ) instead of O(b d ) nodes Which irection hould We earch? Our choices: orward, backwards, or bidirectional The issues: ow many and states are there? ranching factors in each direction ow much work is it to compare states? 25

26 Performance of earch lgorithms on Trees b: branching factor (assume finite) d: depth m: graph depth readth-first search Uniform-cost search 2 epth-first search Iterative deepening idirectional search 3 omplete Y Y N Y Y optimal Y, if Y N Y, if Y, if time O(b d ) O(b */ε ) O(b m ) O(b d ) O(b d/2 ). edge cost constant, or positive non-decreasing in depth 2. edge costs > 0. * is the best path cost 3. both directions ; not always feasible space O(b d ) O(b */ε ) O(bm) O(bd) O(b d/2 ) If tate pace is Not a Tree l The problem: repeated states,,,,,,, l Ignoring repeated states: wasteful () or impossible (). Why? l ow to prevent these problems?,,, If tate pace is Not a Tree l We have to remember already-expanded states (called xplored (aka losed) set) too l Why? l When we pick a node from rontier Remove it from rontier dd it to xplored xpand node, generating all successors or each successor, child, l If child is in xplored or in rontier, throw child away l Otherwise, add it to rontier l alled raph-earch algorithm in igure 3. xample ow are nodes expanded by epth irst earch readth irst earch Uniform ost earch Iterative eepening re the solutions the same? 2

27 Nodes xpanded by: l epth-irst earch: olution found: l readth-irst earch: olution found: l Uniform-ost earch: olution found: l Iterative-eepening earch: olution found: 2