Search. Search Trees

Transcription

1 Search Search Trees node = state arcs = operators search = control epth E F G Fringe or search frontier branching factor = # choices of each node

2 Search riteria ompleteness: guarantees to find a solution when there is one Optimality: highest quality solution where there are different solutions Efficiency: time complexity and space complexity : find the right search criterion for a problem Search lgorithms Types of search algorithms in two perspectives: ased on information used lind Search e.g., depth-first, breath-first, bidirectional search Heuristic Search e.g., hill climbing, best first search, * search ased on search direction (more later) -driven (backward chaining): search from goal states to verify given data ata-driven (forward chaining): search from data to find goal states

3 lind Search lind Search (Uninformed or rute force search) Systematically generates states and test against the goal epends on topology of search tree Is distinguished by the order in which nodes are expanded Has no information about the number of steps or the path cost from current state to the goal state Examples: acktracking epth First readth First acktracking start H E I F J G goal Solution path: G

4 acktracking lgorithm S = current state SL = state list of current path being evaluated for solution NSL = new state list E = dead end list of states whose descendants failed to contain goal node egin SL := [start]; NSL := [start]; E := []; S:= Start; while NSL!= [] do begin if S = goal then return SL; if S has no children then begin while SL is not empty and S = first element of SL do begin add S to E; remove first element from SL; remove first element from NSL; S := first element of NSL end; add S to SL; end else begin place new children of S on NSL; S := first element of NSL; add S to SL end end; return FIL; end H E I start F J G goal I S SL NSL E E E EF 3 H H E HI EF 4 I IE IEF H 5 E E EF IH F F F EIH 6 J J F J F EIH 7 F F F JEIH FJEIH FJEIH 8 G G G FJEIH acktracking lgorithm start start E F G goal H I J Tracing SL H E I F J G goal I S SL NSL E E E EF 3 H H E HI EF 4 I IE IEF H 5 E E EF IH F F F EIH 6 J J F J F EIH 7 F F F JEIH FJEIH FJEIH 8 G G G FJEIH

5 readth-first Search (FS) Expands the shallowest node first start E F G goal lgorithm: H I J EF EFG 1. Let Q = queue contain start state 2. If head of Q is a goal state STOP 3. Generate successors of head and EFG FGHI GHIJ add them at the tail of Q. Remove the head. 4. Go to 2 Solution: trace ancestors - G Node expansion order: EFG epth-first Search (FS) Expands the deepest node first start lgorithm: 1. Let Q = queue contain start state 2. If head of Q is a goal state STOP 3. Generate successors of head and add them at the head of Q. Remove the head. 4. Go to 2 H E I F J G goal EF H I F I F F JG G Solution: FG Node expansion order: EHIFJG

6 omplexity Given b = branching factor, d = solution depth Running time = the time generating nodes at depth 1, 2,..,d = b + b b d Time complexity is O (b d ) for both FS and FS... Space required = max queue length For FS: = # nodes at depth d = b d Space complexity is O (b d ) # nodes generated b b 2 For FS: = bd Space complexity is O (bd) haracteristics FS Shortest path solution Optimal if unit cost (since cost = path length) omplete Time complexity O (b d ) Space complexity O (b d ) FS Space efficiency (Space complexity O(bd)) Not complete (should avoid when space has large/infinite depth) Not optimal (see example 2)

7 FS Example 2 Start E Given cost Solution cost = 18 E Solution: E E E Shortest path solution E Solution path trace ancestors FS Example 2 Start E Given cost Solution cost = 17 Solution: E E E Solution path trace ancestors What is optimal solution? What cost?

8 Other lind Searches Uniform-cost Search: expands the least-cost leaf node first epth-limited Search: places a limit on the FS depth Iterative deepening Search: calls epth-limited search iteratively idirectional Search: searches forward (from start state) and backward (from goal state) and stop where two searches meet Uniform ost Search Expands the least expensive node first Start E E E 16 Solution: E E one - fail Given cost Solution cost = 16 UF gives solution with min. cost of the path traveled so far

9 Other lind Searches epth-limited Search (to avoid drawback of FS) FS that imposes cutoff on the max depth of search path complete if cutoff depth large enough not optimal (like FS) (epth First) Iterative deepening Search (to avoid issue of choosing cutoffs without sacrificing efficiency) calls epth-limited search iteratively for increasing cutoff depth à order of node expansion ~ FS combines benefits of FS and FS good for large search space with unknown solution depth Other lind Searches (contd) idirectional Search (to improve efficiency of FS) searches forward (from start state) and backward (from goal state) and stop where two searches meet Initial state Time complexity O (b d/2 ) What are the requirements of problems that are applicable to this search? state

10 lind Search (contd) Some comparisons omplete? Optimal? readth-first Search yes yes for unit-cost epth-first Search no no Uniform-cost Search yes yes for nondecreasing path cost epth-limited Search only if deep enough no (like FS) Iterative deepening Search yes yes for unit-cost idirectional Search yes yes for unit-cost lind Search Issues Problems with rute force methods Time complexity grows exponentially with size of the problem Eg. Rubik s cube: 4x10 19 nodes hess tree: nodes ombinatorial Explosion! Extremely inefficient Solution: add knowledge to reduce complexity

11 Heuristic Search Luger, h 4 & Reference Texts Outline What are heuristics and heuristic functions? Using heuristics in games Heuristic search algorithms Properties and complexity

12 Heuristics The term Heuristic means to discover rules of thumb that domain experts use to generate good solutions without exhaustive search (Fiegenbaum and Feldman) process that may solve a given problem, but offers no guarantees of doing so (Newell, Shaw and Simon) Technique that improves the average-case performance on a problem-solving task, but not necessary improve the worstcase performance (Russell and Norvig) Using heuristics Efficiency + ccuracy (might miss optimal solution) Heuristics in Search Heuristic Search (or Informed search): uses Problem-specific knowledge Evaluation function determines the order of nodes to be expanded Heuristic evaluation function estimates merit of state with respect to the goal

13 Heuristic functions Examples: Let h(n) = heuristic value of state n Road navigation or route finding h 1 (n) = Euclidean distance from n to goal state h 2 (n) = Expected traveling time Heuristic functions (contd) The 8 puzzle: E.g., h 1 (n) = the number of tiles that are out of place from the goal h 2 (n) = sum of distances out of place h 3 (n) = 2 the number of direct tile reversals state n state Which heuristics to choose? h 1 (n) = 7 h 2 (n) = 18 h 3 (n) = prefer global to local accounts (e.g., h 1 is more global than h 3 but more local than h 2 ) Selection of the best heuristic function is empirical and based on its performance on problem instances

14 Heuristic functions (contd) heuristic evaluation function must provide a reasonable estimate of the merit of a node be inexpensive to compute never over estimate the merit of a node (more later) There are tradeoffs between evaluation time search time Heuristic sacrifices accuracy but why still heuristic? rarely require optimal solution worse case rarely occur learning heuristic helps us understand the problem better Outline What are heuristics and heuristic functions? Using heuristics in games Heuristic search algorithms Properties and issues

15 Representation: Game tree Game playing Nodes: state of the game (e.g. board configuration) ranches: possible moves Leaves: winning states Game trees usually have multiple goal states Heuristic function evaluates game value or pay-off or utility of each node TI-T-TOE max(x) You x x x min(o) Your opponent xo x O x O x O x O O x O x O x x x x x O O O O Multiple goal states o o o x x x o x o o x x x o x o x x x x o o 1 = win 0 = draw -1 = loss terminal utility

16 Game playing program Full game trees are intractable, e.g., TI-T-TOE total # of leaves = 9! reduced states by symmetry (shown in previous slide) = 12 x 7! Two main parts of the program: plausible move generator (static) evaluation function Search game trees One-person games (e.g., 8 puzzle): * Two-person games (e.g., checkers, tic-tac-toe): MINIMX Heuristics for TI-T-TOE Heuristic function, e(n) = x(n) o(n) x(n) = # winning lines for x, x will try to max e o(n) = # winning lines for o, o will try to min e 6-5 = 1 x x 4-6 = -2 x x x o o x x x x o o x x x x o x o x o o o o o o 5-5 = = = = = = = =2 5-6 = = 0

17 Minimax Search depth-limited search procedure Generate possible moves pply evaluation function for each node lternate selection of either max or min child value Repeat process as deep as time allows Minimax Search (contd.) Let p be a search level (ply) While p > 0 do begin if p s parent level is MIN then for each parent node pick min value of its children, else pick max value; propagate the selected value to its parent; p = p 1 end. 1 MX 6-5 = 1 x x x MIN 4-6 = -2 x x o o x x x x o o x x x x o x o x o o o o o o 5-5 = = = = = = = =2 5-6 = = 0

18 Minimax Search (ontd.) Search depth could effect results Max 2 Min Issues: limited look-ahead may lead to bad states later remedy: search deeper UT... search deeper doesn t necessary mean better one-ply search second move two-ply search first move lpha eta Procedure Improve efficiency by pruning Max 2 value of this node = 2 Min cutoff 8

19 lpha eta Procedure α = lower bound of MX node β = upper bound of MIN node α > β à cutoff Max Min 2 α = β = 1 α-cutoff is α-cutoff Min Max 7 7 β = 7 9 α = β-cutoff 1 is β-cutoff More Examples: α-β pruning 3 MX MIN MX Result on Minimax without pruning. Select first move for a three-ply search to obtain a game value 3

20 More Examples: α-β pruning Init: α (lower bound of MX node) = - and β (upper bound of MIN node) = α β Save time on evaluation of five nodes. Result is to choose first move. 2 MX MIN MX More Examples: α-β pruning (contd) MX MIN MX 8 _ 7 3 _ _ 2 _ 4 _ 1 _ 1 _ 3 _ 5 _ 3 _ 9 2 _ _ Save time on evaluation of 11nodes. Result is to choose middle move.

21 est case pruning 9 MX MIN MX ssume left to right evaluation. ny game tree with better pruning? What s its characteristic? est case: the best child is the first one being evaluated ~ O(b d/2 ) # of evaluations = 2b d/2 1 if d even b (d+1)/2 + b (d-1)/2 1 if d is odd [Knuth] Outline What are heuristics and heuristic functions? Using heuristics in games Heuristic search algorithms Properties and issues

22 Heuristic Search asic classifications of heuristic search algorithms Iterative improvement algorithms, e.g., Hill climbing Simulated annealing est-first Search, e.g., Greedy search * Memory bounded search, e.g., Iterative deepening * (I*) Simplified memory-bounded * (SM*) Hill limbing Use generate and test problem-solving strategy lgorithm: (Simple) Hill limbing 1. Let current node be an initial state. 2. If current node is a goal state, STOP (solution found) 3. If current node has no more successor, STOP (no solution found) 4. If successor is better than the current node, make the successor a current node. Go to 2. Note: better can mean lower or higher value. E.g., If h(n) = cost from n to a goal state then better = lower value If h(n) = profit in state n then better = higher value

23 Example: Hill limbing h(n) = profit in state n Start E 5 h(e) = 5 E Solution: E E Solution: E Solutions depend on order of node expansion Gradient Search variation of hill climbing (steepest ascent): Replace better by best in step 4 of the simple hill climbing algorithm. I.e., making the best successor, that is better than current node, a new current node Start E 5 E Solution: E Solutions do not depend on order of node expansion

24 May miss optimal solution Hill limbing Start E 5 Solution: E Solution: E Which is a better solution? Hill limbing: Example What are solution paths from hill climbing algorithms? E 8 F 7 G 5 H 4 L 1 I 6 J 3 K 2 Simple hill climbing: GJ but not optimal Optimal solution: L Gradient search: HK miss solution If K is a goal state... still the solution is non-optimal Hill climbing returns locally optimal solution

25 haracteristics and Issues Hill climbing returns locally optimal solution omplexity: Time omplexity = O(d), where d = longest path length in the tree Space omplexity? Failures in hill climbing search is too local (more later) bad heuristics Example: lockworld Start haracteristics and Issues (cont) Operators: Put(X) puts block X on table Stack(X, Y) puts block X on top of block Y Start

26 haracteristics and Issues (cont) Heuristic1: (an object is either a block or a table) dd one for every block that is attached on the right object Subtract one for every block that is attached on the wrong object 2 Start haracteristics and Issues (cont) Heuristic 2: (a support of X is a set of blocks supporting X) For each block that has correct support, add one for every block in the support For each block that has an incorrect support, subtract one for each block in the support -3 Start =

27 haracteristics and Issues (contd) rawbacks: situations that no progress can be made Foothill (local maxima): always better than neighbors but not necessary better than some other far away Mesa (Plateau): not possible to determine the best direction to move Zig-zag (Ridges): local max has a slope can t traverse a ridge by single moves # # # Remedy: Random-restart hill-climbing acktrack to earlier node ig jumps to new search space Move to several directions at once Simulated nnealing Or Valley escending - a variation of hill climbing where downhill moves may be made at the beginning llows random moves to escape local max can temporarily move to a worse state to avoid being stuck, i.e., If state is better then move, else move with prob. < 1, where the prob. of the badness of the move decreases exponentially nalogous to annealing metals to cool molten metal to solid transition to a higher energy state in cooling process occurs with probability p, where p = e -ΔΕ / T ΔΕ = +ve change in energy level T = Temperature Note: p is propositional to T T initially increases then decreases

28 Simulated nnealing (contd) lgorithm (sketched) 1. current node = an initial state. Initialize T according to the annealing schedule 2. est-so-far = current node 3. Repeat Generate a successor X of a current state; If X is a goal state then return it and STOP else if X is better than current then begin current = X; best-so-far = X end else make X a current state only with probability p = e -ΔΕ / T where ΔΕ = change in values of current node and X; Revise T from the schedule Until a solution is found or current state has no more successor 4. Return est-so-far (ancestors are traced for a solution path) Simulated nnealing (contd) Start E 2 H 7 Hill climbing: stuck at Gradient search: stuck at H Simulated nnealing: FG (if generates first) HEG (if uses gradient search variation) F 6 G 10

29 Heuristic Search asic classifications of heuristic search algorithms Iterative improvement algorithms, e.g., Hill climbing Simulated annealing est-first Search, e.g., Greedy search * Memory bounded search, e.g., Iterative deepening * (I*) Simplified memory-bounded * (SM*) est First Search Expand the node with lowest cost first to find a low-cost solution Uses heuristic cost evaluation function f(n) for node n Idea: Loop until goal is found or no node left to generate hoose the best of the nodes generated so far. If it is goal then quit. Generate the successors of the chosen node dd all new nodes to the set of nodes generated so far

30 Example 1 Start F 0 E 4 f() = 25 f(f) = 0, etc. best = smallest value E 4 solution: EF 10 F 0 est First Search lgorithm lgorithm: 1 OPEN = [start]; LOSE = []; 2 If OPEN = [], exit with FIL; 3 hoose best node from OPEN, call it X; 4 If X is a goal node, exit with a traced solution path; 5 Remove X from OPEN to LOSE; 6 Generate successors of X (record X as their parent) For each successor S of X i) Evaluate f(s); ii) If S is new (i.e., not on OPEN, LOSE), add it to OPEN iii) If S is not new, compare f(s) on this path to previous one If previous is better or same, keep previous and discard S Otherwise, replace previous by S. If S is in LOSE, move it back to OPEN 7 Go to 2 Start f() = 25, f(f) = 0, etc F 0 X OPEN LOSE , ,E4,17 15,25 E4 F0,10,17 E4, 15,25 F0 F0,10,17 E4,15,25 Solution EF E 4

31 Evaluation ost Functions Start S g(n) n h(n) G f(n) = cost of state n from start state to goal state g(n) = cost from start state to state n h(n) = cost from state n to goal state In est First Search, an evaluation cost function of state n f ʹ (n) = g(n) + hʹ (n), where f ʹ (n) is estimate of f(n) hʹ (n) is a heuristic estimate of h(n) Example 2 Start F 0 hʹ () = 25 4 E hʹ (F) = 0, etc. f ʹ (n) = g(n) + hʹ (n) solution: EF 17+9= = =21 E 4+18= =31 E 4+16=20 F 0+20

32 est First Search: Example 2 lgorithm: 1 OPEN = [start]; LOSE = []; 2 If OPEN = [], exit with FIL; 3 hoose best node from OPEN, call it X; 4 If X is a goal node, exit with a traced solution path; 5 Remove X from OPEN to LOSE; 6 Generate successors of X (record X as their parent) For each successor S of X i) Evaluate f(s); = g(s) + hʹ (S) ii) If S is new (i.e., not on OPEN, LOSE), add it to OPEN iii) If S is not new, compare f(s) on this path to previous one If previous is better or same, keep previous and discard S Otherwise, replace previous by S. If S is in LOSE, move it back to OPEN 7 Go to 2 Start hʹ () = 25, hʹ (F) = 0, etc OPEN F E 4 LOSE , ,E22,26 22,25 39 E22,26 21,22,25 31,E20,30, F20E,26 E20,21, 42E,31E 22, Solution EF 0 Evaluation ost Functions & Search Start S g(n) n h(n) G f(n) = cost of state n from start state to goal state g(n) = cost from start state to state n h(n) = cost from state n to goal state In est First Search, an evaluation cost function of state n f ʹ (n) = g(n) + hʹ (n), where f ʹ (n) is estimate of f(n) hʹ (n) is a heuristic estimate of h(n) Special cases: Uniform cost search: f ʹ (n) = g(n) readth First Search: f ʹ (n) = g(n), where g depth Greedy search: f ʹ (n) = hʹ (n) *: f ʹ (n) = g(n) + hʹ (n) where hʹ (n) is admissible (later)

33 Outline What are heuristics and heuristic functions? Using heuristics in games Heuristic search algorithms Properties and issues Uniform ost Search: Minimizes g(n) Some properties Expands node on the least cost path first à Gives solution with minimal distance traveled oesn t direct search towards goal Greedy Search: Minimizes hʹ (n) Expands node closest to the goal à Reaches the goal fast irects search towards goal disregarding traveling distance à not optimal *: Minimizes g(n) + hʹ (n) alances both costs

34 I 1 +2 E 1 +3 J 0 +3 F 1 +4 G 1 +5 H 0 dmissibility hʹ (n) is given near the node, g(n) = depth(n) Using f ʹ (n) = g(n) + hʹ (n): Solution IJ H is not generated Suppose F is also a goal: Solution EF G, H,, I, J not generated Solution is not optimal cost 5 instead of 3 Problem: hʹ () > h*() hʹ overestimates h where h*(n) = cost on the optimal path from state n to goal state Here h*() = 2 from an optimal path IJ Suppose hʹ () = 2 à hʹ () h*(): Solution IJ optimal, and F, G, H not generated If hʹ (n) h*(n) h(n) for all n, then hʹ is admissible (e.g., see IJ) dmissibility (contd) If hʹ (n) = h*(n) then goal state is converged with no search If hʹ overestimates h* à hʹ is worse (larger) than its actual optimal cost (i.e., hʹ (n) > h*(n) for some n) à hʹ is pessimistic and the node may not get chosen à could miss optimal solution (earlier example hʹ () = 4) If hʹ never overestimates h* (i.e., hʹ (n) h*(n) for all n) à hʹ is better than its actual optimal cost admissible condition à hʹ is optimistic and the node gets chosen Search satisfies admissible condition is admissible dmissibility guarantees optimal solution if it exists * (satisfies admissible conditions) is complete and optimal

35 Monotonicity For hʹ (goal) = 0, hʹ is monotone if for all n and its descendent m hʹ (n) cost(n,m) + hʹ (m) Start S The above implies f ʹ (m) f ʹ (n) g(n) and thus (monotone non-decreasing gives) the name n Monotonicity ~ locally admissible à reaching each state along optimal path thus, it guarantees optimal path to any state the first time the state is discovered cost(n,m) h'(m) m h'(n) G Monotonicity (contd) onsequences of monotone heuristics in search algorithms can ignore a state discovered a second time no need to update the path information Monotonicity implies admissibility Uniform cost search gives optimal solution when it is monotone i.e., when cost(n,m) 0

36 Examples h 1 (n) = 0 for all n h 2 (n) = straight line distance from state n to a goal state h 1 and h 2 are admissible and monotonic The 8 puzzle: E.g., h 3 (n) = the number of tiles that are out of place from the goal h 4 (n) = sum of distances out of place h 5 (n) = 2 the number of direct tile reversals ll are less than or equal to the number of moves required to move the tiles to the goal position (I.e., actual cost) à all are admissible Informedness Let h 1 and h 2 be heuristics in two * algorithms, h 2 is more informed than h 1 if (1) h 1 (n) h 2 (n) for all n, and (2) h 1 (m) < h 2 (m) for some m E.g., h 2 is more informed than h 1 for h 1 (n) = 0 for all n, and h 2 (n) = estimate distance from state n to a goal state More informed heuristics reduce search space 4 Example: onsider two * searches: 1. f(n) = depth(n) + h 1 (n) 2. f(n) = depth(n) + h 2 (n) F G H 2 I 0 J Search 1 covers entire space Search 2 covers partial space K L

37 Other heuristic searches Iterative improvement algorithms Hill climbing: moves to a better state Simulated annealing: random moves to escape local max est-first Search Greedy search: expands the node closest to the goal *: expands the node on the least-cost solution path Other search variations eam search O* Memory bounded search Iterative deepening * (I*) Simplified memory-bounded * (SM*) pplications of search algorithms Two important problem classes: Game playing (discussed earlier) onstraint Satisfaction Problems (SP)

38 SP States are defined by values of a set of variables is a set of constraints of the values Solution specifies values of all variables such that the constraints are satisfied Real-world problems: esign VLSI layout Scheduling problems SP (contd) Search in SP with 1) x$2 2) x + y = z 3) y#z!3 4) x+y+z#12 (x, y, z) Start state x=2 (2, y, z) propagate thru (2, y, 2+y) constraint 2) Forward checking: no y satisfies 3) acktrack x=4 (4, y, z) propagate thru (4, y, 4+y) y=2 (4, 2, 6) constraint 2) y=3 Solution violates 4) (4, 3, 7) rc consistency: delete y=3, z=7 acktrack

39 SP (contd) Techniques required acktracking Forward checking rc consistency which exhibits onstraint propagation Efficiency in searching in SP depends on selecting which variable what value Heuristics in SP: Most-constraining-variable less future variable choices Least-constraining-value more freedom for future values