Topic 1 Uninformed Search (Updates: Jan. 30, 2017)

Transcription

1 Topic 1 Uninformed Search (Updates: Jan. 30, 2017) Uninformed search is brute-force search. Uninformed search is also called blind search. 1. Depth-First Search (DFS) 2. Breadth-First Search (BFS) 3. Depth-Limited Search (DLS) is a variant of DFS. 4. Iterative-Deepening Search (IDS) is a variant of DLS. 5. Uniform-Cost Search (UCS) is a variant of BFS. 6. Bidirectional Search (BDS) is a variant of BFS. 1. Depth-First Search (DFS) [George F. Luger. Artificial Intelligence Structures and Strategies for Complex Problem Solving.] function DFS; open := [Start]; % initialize closed := [ ]; while open [ ] do % states remain remove leftmost state from open, call it X; if X is a goal then return SUCCESS % goal found else generate children of X; put X on closed; discard children of X if already on open or closed; % loop check put remaining children on left end of open % stack end end; return FAIL % no states left end. Figure 3.15 Graph for depth-first search example. A trace of DFS on the graph of Figure 3.15 follows. Each successive number, 1, 2, 3,..., represents an iteration of the while loop. U is the goal state. 1

2 0. open = [A]; closed = [ ] 1. open = [B,C,D]; closed = [A] 2. open = [E,F,C,D]; closed = [B,A] 3. open = [K,L,F,C,D]; closed = [E,B,A] 4. open = [S,L,F,C,D]; closed = [K,E,B,A] 5. open = [L,F,C,D]; closed = [S,K,E,B,A] 6. open = [T,F,C,D]; closed = [L,S,K,E,B,A] 7. open = [F,C,D]; closed = [T,L,S,K,E,B,A] 8. open = [M,C,D], (as L is already on closed); closed = [F,T,L,S,K,E,B,A] 9. open = [C,D]; closed = [M,F,T,L,S,K,E,B,A] 10. open = [G,H,D]; closed = [C,M,F,T,L,S,K,E,B,A] 11. and so on until either U is found or open = [ ]. The open list defines the search frontier (i.e., which nodes to explore next). The closed list defines the nodes that have already been explored, and is used to avoid revisiting nodes and avoids loops. 2. Breadth-First Search (BFS) [George F Luger. Artificial Intelligence Structures and Strategies for Complex Problem Solving.] function BFS; open := [Start]; % initialize closed := [ ]; while open [ ] do % states remain remove leftmost state from open, call it X; if X is a goal then return SUCCESS % goal found else generate children of X; put X on closed; discard children of X if already on open or closed; % loop check put remaining children on right end of open % queue end end return FAIL % no states left end. Figure 3.15 Graph for breadth-first search example. 2

3 A trace of BFS on the graph of Figure 3.15 follows. Each successive number, 1, 2, 3,..., represents an iteration of the while loop. U is the goal state. 0. open = [A]; closed = [ ] 1. open = [B,C,D]; closed = [A] 2. open = [C,D,E,F]; closed = [B,A] 3. open = [D,E,F,G,H]; closed = [C,B,A] 4. open = [E,F,G,H,I,J]; closed = [D,C,B,A] 5. open = [F,G,H,I,J,K,L]; closed = [E,D,C,B,A] 6. open = [G,H,I,J,K,L,M] (as L is already on open); closed = [F,E,D,C,B,A] 7. open = [H,I,J,K,L,M,N]; closed = [G,F,E,D,C,B,A] 8. and so on until either U is found or open = [ ]. 3. Depth-Limited Search (DLS) [George F Luger. Artificial Intelligence Structures and Strategies for Complex Problem Solving.] function DLS(l); // depth limit (or bound) l = 0, 1, 2,... open := [Start]; % initialize closed := [ ]; while open [ ] do % states remain remove leftmost state from open, call it X; put X on closed; if X is a goal then return SUCCESS % goal found if the depth of X is equal to the depth limit, go back to while loop else generate children of X; discard children of X if already on open or closed; % loop check put remaining children on left end of open % stack end end; return FAIL % no states left end. Figure 3.15 Graph for depth-limited search example. 3

4 A trace of DLS (with depth limit = 2) on the graph of Figure 3.15 follows. Each successive number, 1, 2, 3,..., represents an iteration of the while loop. U is the goal state. 0. open = [A]; closed = [ ] 1. open = [B,C,D]; closed = [A]; X = A; depth(a) = 0 < 2 2. open = [E,F,C,D]; closed = [B,A]; X = B; depth(b) = 1 < 2 3. open = [F,C,D]; closed = [E,B,A]; X = E; depth(e) = 2 = limit 4. open = [C,D]; closed = [F,E,B,A]; X = F; depth(f) = 2 = limit 5. open = [G,H,D]; closed = [C,F,E,B,A]; X = C; depth(c) = 1 < 2 6. open = [H,D]; closed = [G,C,F,E,B,A]; X = G; depth(g) = 2 = limit 7. open = [D]; closed = [H,G,C,F,E,B,A]; X = H; depth(h) = 2 = limit 8. open = [I,J], closed = [D,H,G,C,F,E,B,A]; X = D; depth(d) = 1 < 2 9. open = [J]; closed = [I,D,H,G,C,F,E,B,A]; X = I; depth(i) = 2 = limit 10. open = []; closed = [J,I,D,H,G,C,F,E,B,A]; X = J; depth(j) = 2 = limit 11. open = [ ]. % return FAIL 4. Iterative-Deepening Search (IDS) IDS performs a DLS of the state space with a depth bound of 0. If it fails to find a goal, DLS performs another DLS with a depth bound of 1. This continues, increasing the depth bound by one each time. At each iteration, the algorithm performs a complete DLS with the current depth limit. No information about the state space is retained between iterations. 5. Uniform-Cost Search (UCS) Figure 3.10 Node order in IDS [Matthew L. Ginsberg] UCS (or Branch and Bound) is a variation of BestFS. Let us denote the following notations. - g(n) is the lowest path cost of going from the start node s to the current node n. - h(n) is the heuristically estimated distance from the current node n to the goal node g. - f(n) = g(n) + h(n) is called a heuristic evaluation function. f(n) is the heuristically estimated distance from the start node s to the goal node g. 4

5 UCS uses only g(n) when exploring (examining) each node n. The node with the lowest value of g is expanded first. [Stuart J. Russell, Peter Norvig. Artificial Intelligence A Modern Approach.] function UNIFORM-COST-SEARCH(problem) returns a solution, or failure node a node with STATE = problem.initial-state, PATH-COST = 0 frontier a priority queue ordered by PATH-COST, with node as the only element explored an empty set loop do if EMPTY?(frontier) then return failure node POP(frontier) /* chooses the lowest-cost node in frontier, DEQUEUE */ if problem.goal-test(node.state) then return SOLUTION(node) add node.state to explored for each action in problem.actions(node.state) do child CHILD-NODE(problem, node, action) if child.state is not in explored or frontier then // assign the child a distance value: g(child) = g(node) + cost(node, child) frontier INSERT(child, frontier) // ENQUEUE else if child.state is in frontier with better PATH-COST then replace that frontier node with child // keep a single copy of the child with the smaller g-value among the two copies Figure 3.14 Uniform-cost search on a graph. The algorithm is identical to the general graph search algorithm in Figure 3.7, except for the use of a priority queue and the addition of an extra check in case a shorter path to a frontier state is discovered. The data structure for frontier needs to support efficient membership testing, so it should combine the capabilities of a priority queue and a hash table. // frontier = open list, explored = closed list /* EMPTY?(queue) returns true only if there are no more elements in the queue. POP(queue) removes the first element (i.e., the oldest element) of the queue and returns it. INSERT(element, queue) inserts an element and returns the resulting queue. n.state: the state in the state space to which the node corresponds; n.parent: the node in the search tree that generated this node; n.action: the action that was applied to the parent to generate the node; n.path-cost: the cost, traditionally denoted by g(n), of the path from the initial state to the node, as indicated by the parent pointers. function CHILD-NODE(problem, parent, action) returns a node return a node with STATE = problem.result(parent.state, action), PARENT = parent, ACTION = action, PATH-COST = parent.path-cost + problem.step-cost(parent.state, action) 5

6 Figure 3.10 Nodes are the data structures from which the search tree is constructed. Each has a parent, a state, and various bookkeeping fields. Arrows point from child to parent. */ BFS always expands the shallowest unexpanded node. UCS expands the node n with the lowest path cost g(n) by storing the frontier as a priority queue ordered by g. UCS expands nodes in order of their optimal path cost. Hence, the first goal node selected for expansion must be the optimal solution. Two other significant differences between UCS and BFS. - The first is that the goal test is applied to a node when it is selected for expansion (as in the generic graph-search algorithm shown in Figure 3.7) rather than when it is first generated. The reason is that the first goal node that is generated may be on a suboptimal path. - The second difference is that a test is added in case a better path is found to a node currently on the frontier. Both of these modifications come into play in the shown in Figure 3.15, where the problem is to get from Sibiu to Bucharest. The successors of Sibiu are Rimnicu Vilcea and Fagaras, with costs 80 and 99, respectively. The least-cost node, Rimnicu Vilcea, is expanded next, adding Pitesti with cost = 177. The least-cost node is now Fagaras, so it is expanded, adding Bucharest with cost = 310. Now a goal node has been generated, but uniform-cost search keeps going, choosing Pitesti for expansion and adding a second path to Bucharest with cost = 278. Now the algorithm checks to see if this new path is better than the old one; it is, so the old one is discarded. Bucharest, now with g-cost 278, is selected for expansion and the solution is returned. 6

7 Figure 3.15 Part of the Romania state space, selected to illustrate uniform-cost search. [End of Stuart J. Russell, Peter Norvig. Artificial Intelligence A Modern Approach.] [Source: Position Paper: Dijkstra s Algorithm versus Uniform Cost Search or a Case Against Dijkstra s Algorithm by Ariel Felner] Algorithm 2: Uniform-Coast Search // Ariel Felner Input: Source vertex s 1. open.insert(s) // open is a priority queue, initially closed = [] 2. while open empty do 3. u = open.extract_min() 4. if u is a goal then return the corresponding solution 5. for each vertex v Adj(u) do // for each child v of u 6. g(v) = g(u) + cost(u, v) 7. v = check_for_duplicates(v) 8. open.insert(v ) 9. closed.insert(u) Duplicate check for UCS Duplicate checks might be slightly different for different versions of best-first search. For UCS it is done as follows. When a new node v is generated, we check whether it is already in open. If it is, we keep a single copy of v with the smallest g-value among the two copies (labeled v in Algorithm 2). If v is in closed, its new copy is discarded. 1 1 In some versions of best-first search, if the new copy of v has a better cost than the copy in closed, v is removed from closed and is reinserted to open with the new cost. This process is called node reopening and only occurs if the cost function is non-monotonic (Felner et al. 2010). open = [S] closed = [] 1. u = X = S; open = [] v = B: g(v) = g(b) = g(s) + cost(s, B) = = 80 v = C: g(v) = g(c) = g(s) + cost(s, C) = = 99 open = [S B(80), S C(99)] closed = [S] 2. u = X = B; open = [S C(99)] v = D: g(v) = g(d) = g(b) + cost(b, D) = = 177 open = [S C(99), S B D(177)] closed = [S, B] 3. u = X = C; open = [S B D(177)] v = E: g(v) = g(e) = g(c) + cost(c, E) = = 310 open = [S B D(177), S C E(310)] 7

8 closed = [S, B, C] 4. u = X = D; open = [S C E(310)] v = E: g(v) = g(e) = g(d) + cost(d, E) = = 278 open = [S B D E(278), S C E(310)] = [S B D E(278)] closed = [S, B, C, D] 5. u = X = E; open = [] u = E is a goal then return the corresponding solution: S B D E(278) v = none closed = [S, B, C, D, E] 6. open = [] stop. //Solution: S B D E(278) [End of Position Paper: Dijkstra s Algorithm versus Uniform Cost Search or a Case Against Dijkstra s Algorithm] 6. Bidirectional Search (BDS) Notations used are as follows. s = start (initial) node, t = terminal (goal) node. S = set of nodes reached from s whose minimum distance from s is known. S = set of nodes reached from S by one edge but are not in S. gs(x) = current shortest distance from s to x. gs(s) = 0 wf(x) = the immediate predecessor node of x along the path from s to x (i.e., parent of x). T = set of nodes which have a path to t whose minimum distance is already found. T = set of nodes reached from T by one edge but are not in T. gt(x) = current shortest distance from x to t. wt(x) = the immediate successor node of x along the path from x to t (i.e., child of x). Call the forward algorithm F and the backward algorithm B; we now wish to combine them into a bidirectional search (BDS) algorithm. Algorithm BDS // Ira Pohl 1. (Initialize) Perform F1 (the first step of the forward algorithm) and B1. That is, S = {s}, T = {t} 2. (Strategy) Decide to go forward (go to Step 3) or backward (go to Step 4). 3. (Forward expansion) Perform F2. If n T go to Step 5 else go to Step (Backward expansion) Perform B2. If n S go to Step 5 else go to Step (Terminate) If x S T, stop. The solution path is (s x t). Example: Apply the BDS to the figure given below, where start node is A and goal node is I. 8

9 1. F1: S = {A}, B1: T = {I} 2. Decide to go to Step F2: S = {A, E, B, J}. Go back to Step 2 2. Decide to go to Step B2: T = {I, G}. Go back to Step 2 2. Decide to go to Step B3: T = {I, G, E, H}. Check n = E S so go to Step x S T = {E}. Stop. The solution path is (A E G I) It is noted that the decision made in Step 2 really affects the performance of the bidirectional search (BDS). Notes: The cardinality comparison principle can be used for Step 2 as follows. // 2. (Strategy) Decide to go forward (go to Step 3) or backward (go to Step 4). 2. If S < T then go to Step 3 else go to Step 4. Comparing uninformed search strategies [Stuart J. Russell, Peter Norvig. Artificial Intelligence A Modern Approach.] Criterion Breadth- First Uniform- Cost Depth- First Depth- Limited Iterative Deepening Bidirectional (if applicable) Complete? Yes a Yes a, b No No Yes a Yes a, d Time Space Optimal? Yes c Yes No No Yes c Yes c, d Figure 3.21 Evaluation of tree-search strategies. b is the branching factor; d is the depth of the shallowest solution; m is the maximum depth of the search tree; l is the depth limit. Superscript caveats are as follows: a complete if b is finite; b complete if step costs for positive ; c optimal if step costs are all identical; d if both directions use breadth-first search. [End of Stuart J. Russell, Peter Norvig. Artificial Intelligence A Modern Approach.] 9

10 [M. Tim Jones. Artificial Intelligence A Systems Approach.] Algorithm Time Space Optimal Complete Derivative DFS O(b m ) O(bm) No No DLS O(b l ) O(bl) No No DFS IDS O(b d ) O(bd) Yes No DLS BFS O(b d ) O(b d ) Yes Yes BDS O(b d/2 ) O(b d/2 ) Yes Yes BFS UCS O(b d ) O(b d ) Yes Yes BFS b: branching factor, d: solution depth, m: tree depth, l: search depth limit [End of M. Tim Jones. Artificial Intelligence A Systems Approach.] References M. Tim Jones Artificial Intelligence A Systems Approach. Jones & Bartlett Learning. ISBN: Ben Coppin Artificial Intelligence Illuminated. Jones & Bartlett Learning. ISBN: George F Luger Artificial Intelligence Structures and Strategies for Complex Problem Solving. 6 th Ed. Pearson. ISBN: Stuart J. Russell, Peter Norvig Artificial Intelligence A Modern Approach. 3 rd Ed. Pearson. ISBN: Matthew L. Ginsberg Essentials of Artificial Intelligence. Morgan Kaufmann. ISBN: Thomas Dean, James Allen, Yiannis Aloimonos Artificial Intelligence: Theory and Practice. Addison-Wesley. ISBN: Patrick Henry Winston Artificial Intelligence. 3 rd Ed. Pearson. ISBN: Crina Grosan, Ajith Abraham Intelligent Systems A Modern Approach. Springer. ISBN: Ivan Bratko Prolog Programming for Artificial Intelligence. 4 th Ed. Pearson. ISBN: Pohl, Ira, Bi-directional Search, in Meltzer, B.; Michie, D. (eds.), Machine Intelligence 6, Edinburgh University Press, Edinburgh, 1971, pp

11 11