HW#1 due today. HW#2 due Monday, 9/09/13, in class Continue reading Chapter 3

Transcription

1

2 Uninformed (blind) search algorithms Breadth-First Search (BFS) Uniform-Cost Search Depth-First Search (DFS) Depth-Limited Search Iterative Deepening Best-First Search HW#1 due today HW#2 due Monday, 9/09/13, in class Continue reading Chapter 3

3

4 Formulate Search Execute 1. Goal formulation 2. Problem formulation 3. Search algorithm 4. Execution

5 A problem is defined by four items: 1. initial state 2. actions or successor function 3. goal test (explicit or implicit) 4. path cost ( c(x,a,y) sum of step costs) A solution is a sequence of actions leading from the initial state to a goal state

6 Search algorithms have the following basic form: do until terminating condition is met if no more nodes to consider then return fail; select node; {choose a node (leaf) on the tree} if chosen node is a goal then return success; expand node; {generate successors & add to tree} Analysis b = branching factor d = depth m = maximum depth

7

8 g(n) = the total cost of the path on the search tree from the root node to node n h(n) = the straight line distance from n to G n S A B C G h(n)

9

10 Uninformed search strategies use only the information available in the problem definition Breadth-first search Uniform-cost search Depth-first search Depth-limited search Iterative deepening search

11 Expand shallowest unexpanded node Implementation: fringe is a FIFO queue, i.e., new successors go at end

12 idea: order the branches under each node so that the most promising ones are explored first g(n) is the total cost of the path on the search tree from the root node to node n sort the open list by increasing g(), that is, consider the shortest partial path first

13 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

14 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

15 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

16 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

17 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

18 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

19 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

20 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

21 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

22 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

23 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

24 Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

25 Complete? No: fails in infinite-depth spaces, spaces with loops Modify to avoid repeated states along path complete in finite spaces Time? O(b m ): terrible if m is much larger than d but if solutions are dense, may be much faster than BFS Space? O(bm), i.e., linear space! Optimal? No

26 = depth-first search with depth limit l, i.e., nodes at depth l have no successors Recursive implementation:

27

28

29

30

31

32

33

34 Number of nodes generated in a depth-limited search to depth d with branching factor b: N DLS = b 0 + b 1 + b b d-2 + b d-1 + b d Number of nodes generated in an iterative deepening search to depth d with branching factor b: N IDS = (d+1)b 0 + d b^1 + (d-1)b^ b d-2 +2b d-1 + 1b d For b = 10, d = 5, N DLS = , , ,000 = 111,111 N IDS = , , ,000 = 123,456 Overhead = (123, ,111)/111,111 = 11%

35 Complete? Yes Time? (d+1)b 0 + d b 1 + (d-1)b b d = O(b d ) Space? O(bd) Optimal? Only if step cost = 1; otherwise NO

36

37 Problem formulation usually requires abstracting away real-world details to define a state space that can feasibly be explored Variety of uninformed search strategies Iterative deepening search uses only linear space and not much more time than other uninformed algorithms

38 Idea: use an evaluation function f(n) for each node estimate of "desirability" Expand most desirable unexpanded node Implementation: Order the nodes in the Open List (fringe) in decreasing order of desirability Special cases: greedy best-first search A * search

39 g(n) path-cost function = cost of the path from the root to node n found so far (less than or equal to g*(n)) h(n) heuristic function estimates the cost of a path from node n to the closest goal node ( f(n) evaluation function measure of how likely node n is part of a solution one possibility: f(n) = g(n) + h(n)

40 Possible evaluation functions: f(n) = probability that a node is on the right path f(n) = distance function (measure of the difference between node n & the nearest goal node) f(n) = g(n) f(n) = h(n) f(n) = g(n) + h(n) Uniform Cost Greedy A* estimates the total cost of a solution path which goes through node n

41

42 Evaluation function f(n) = h(n) (heuristic) = estimate of cost from n to goal e.g., h SLD (n) = straight-line distance from n to Bucharest Greedy best-first search expands the node that appears to be closest to goal

43

44

45

46

47 Complete? No can get stuck in loops, e.g., Iasi Neamt Iasi Neamt Time? O(b m ), but a good heuristic can give dramatic improvement Space? O(b m ) -- keeps all nodes in memory Optimal? No

48 Idea: avoid expanding paths that are already expensive prune longer paths (if there is >1 path from the root to node n, only keep the shortest on the search tree) Evaluation function f(n) = g(n) + h(n) g(n) = lowest cost so far to reach n h(n) = estimated cost from n to goal f(n) = estimated total cost of path through n to goal

49 f(n) estimates the total cost of a solution path which goes through node n f(n) = g(n) + h(n) lowest-cost path from S to n (found so far) heuristic estimate of cost from n to G

50 for a node, N, N h(n) N g(n) heuristic function (superscript) path-cost function (subscript)

51

52

53

54

55

56

57 A heuristic h(n) is admissible if for every node n, h(n) h * (n), where h * (n) is the true cost to reach the goal state from n. An admissible heuristic never overestimates the cost to reach the goal, i.e., it is optimistic Example: h SLD (n) (never overestimates the actual road distance) Theorem: If h(n) is admissible, A * using TREE-SEARCH is optimal

58 A heuristic is consistent if for every node n, every successor n' of n generated by any action a, h(n) c(n,a,n') + h(n') If h is consistent, we have f(n') = g(n') + h(n') = g(n) + c(n,a,n') + h(n') g(n) + h(n) = f(n) i.e., f(n) is non-decreasing along any path. Theorem: If h(n) is consistent, A* using GRAPH-SEARCH is optimal

59 The following figure shows a portion of a partially expanded search tree. Each arc between nodes is labeled with the cost of the corresponding operator, and the leaves are labeled with the value of the heuristic function, h. Which node (use the node s letter) will be expanded next by each of the following search algorithms? A h=20 (a) Depth-first search (b) Breadth-first search (c) Uniform-cost search (d) Greedy search (e) A* search h=14 B E F G H h=10 h=12 h=8 h=10 C 19 h=18 5 D h=15

60 Search DFS Depth Limited BFS Iterative Deepening Uniform Cost g(n) BMA* Greedy f(n) =h(n) BestFS f(n) A* f(n)=g(n)+h(n) cf: Animated Search Algorithms at * British Museum Algorithm (i.e. Exhaustive Search)