ARTIFICIAL INTELLIGENCE. Pathfinding and search

Transcription

1 INFOB2KI Utrecht University The Netherlands ARTIFICIAL INTELLIGENCE Pathfinding and search Lecturer: Silja Renooij These slides are part of the INFOB2KI Course Notes available from

2 Pathfinding `Physical world: open space or structured? 2

3 Pathfinding in Romania 3

4 1. State space Searching E.g. all cities on a map, or all possible paths in a grid or (waypoint) graph 2. Operators or production rules E.g. change from one path to another by changing some arcs 3. Strategy How to search through the state space E.g. Systematic (desirable, not always possible): All states are visited No state is visited more than once 4

5 Selecting a state space Real world is absurdly complex state space must be abstracted for problem solving (Abstract) state S represents (set of) real state(s) A problem typically assigns an initial state (e.g "in Arad ) and a goal state (e.g. "in Zerind ) (Abstract) action S S represents complex combination of real actions Each abstract action should be "easier" than the original problem e.g., "Arad Zerind" represents a complex set of possible routes, detours, rest stops, etc. (Abstract) solutions represent solutions in the real world for guaranteed realizability, a sequence of actions maps initial state to goal state E.g list of connections = real path 5

6 State space and path finding Often the state space is too large to represent all solutions create while searching (! Simple search algorithms typically build trees (tree search) or graphs (graph search) with solutions; these terms do not refer to the representation of physical world or state space!) Create (portions of) all paths while finding a good path between two points Be careful, in pathfinding state space is NOT necessarily the same as all nodes of the grid/waypoint graph! State space could be the set of all paths (lists of connections) on this grid/graph! 6

7 Dijkstra s algorithm Bookkeeping: Open list (seen, but not processed) Closed list (completely processed) Cost so far + connection followed to get there Edsger W. Dijkstra Init: Open list (start node, cost so far=0) Iteration: Process node from open list with smallest cost so far Terminate: When open list is empty Follow back connections to retrieve path 7

8 Dijkstra s algorithm Open: (Arad,0) Closed: 8

9 Dijkstra s algorithm Open: (Z,75) Arrad, (S,140) A, (T,118) A Closed: (Arad,0) 9

10 Dijkstra s algorithm Open: (S,140) A, (T,118) A, (O,146) Z Closed: (Arad,0), (Z,75) A 10

11 Dijkstra s algorithm Open: (S,140) A, (O,146) Z, (L,229) T Closed: (Arad,0), (Z,75) A, (T,118) A 11

12 Dijkstra s algorithm > 146 Open: (O,146) Z, (L,229) T, (R,220) S, (F,239) S Closed: (Arad,0), (Z,75) A, (T,118) A, (S,140) A 12

13 Dijkstra s algorithm Open: (L,229) T, (R,220) S, (F,239) S Closed: (Arad,0), (Z,75) A, (T,118) A, (S,140) A, (O,146) Z 13

14 Dijkstra s algorithm Open: (L,229) T, (F,239) S, (C,366) R, (P,317) R Closed: (Arad,0), (Z,75) A, (T,118) A, (S,140) A, (O,146) Z, (R,220) S 14

15 Dijkstra s algorithm Open: (F,239) S, (C,366) R, (P,317) R, (M,299) L Closed: (Arad,0), (Z,75) A, (T,118) A, (S,140) A, (O,146) Z, (R,220) S, (L,229) T 15

16 Dijkstra s algorithm Open: (C,366) R, (P,317) R, (M,299) L, Closed: (Arad,0), (Z,75) A, (T,118) A, (S,140) A, (B,450) F (O,146) Z, (R,220) S, (L,229) T, (F,239) S 16

17 Dijkstra s algorithm Open: (C,366) R, (P,317) R, (B,450) F, Closed: (Arad,0), (Z,75) A, (T,118) A, (S,140) A, (D,374) M (O,146) Z, (R,220) S, (L,229) T, (F,239) S, (M,299) L 17

18 Dijkstra s algorithm >366 Open: (C,366) R, (B,450) F, (D,374) M, Closed:(Arad,0), (Z,75) A, (T,118) A, (S,140) A, (B,418) P (O,146) Z, (R,220) S, (L,229) T, (F,239) S, (M,299) L, (P,317) R 18

19 Dijkstra s algorithm >374 Open: (D,374) M, (B,418) P Closed:(Arad,0), (Z,75) A, (T,118) A, (S,140) A, (O,146) Z, (R,220) S, (L,229) T, (F,239) S, (M,299) L, (P,317) R, (C,366) R 19

20 Dijkstra s algorithm Open: (B,418) P Etc. Closed: (Arad,0), (Z,75) A, (T,118) A, (S,140) A (O,146) Z, (R,220) S, (L,229) T, (F,239) S, (M,299) L, (P,317) R, (C,366) R, (Dijkstra continues, we stop ) (D,374) M 20

21 Dijkstra s algorithm Retrieve path to Bucharest (Arad,0), (Z,75) A, (T,118) A, (S,140) A, (O,146) Z, (R,220) S, (L,229) T, (F,239) S, (M,299) L, (P,317) R, (C,366) R, (D,374) M, (B,418) P 21

22 Dijkstra s algorithm Start with paths of length 1 and expand the one with lowest (non negative!) cost first Graph search algorithm that solves the single source shortest path problem All paths in the graph will be found (and no path will be found more than once) Not aimed at finding path to one specific goal 22

23 Tree search algorithms Simulated exploration of state space by generating successors of already explored states (a.k.a. expanding) start state initial node of tree expand: generate leafs for successors fringe (= frontier = open list) with all leafs goal state: used in goal test Note: goal test when node is considered for expansion, not already upon generation! 23

24 Implementation: states vs. nodes As before: a state S is an abstract representation of a physical configuration A node x is part of a search tree or search graph; it is a data structure containing info on: state S parent node action path cost g(x), depth, Expand: function that creates new nodes fills in the various node fields uses problem associated Successor Fn to generate successors 25

25 Tree search example Node for initial state Arad in fringe 26

26 Tree search example Node related to state Arad is expanded and removed from fringe Nodes related to states Sibiu (~path from Arad to Sibiu), Timisoara and Zerind are generated and added to the fringe 27

27 Tree search example Suppose strategy selects node related to state Sibiu for expansion: a.o. node related to state Arad is generated and added to the fringe oops.there s a loop.! 28

28 Repeated states Failure to detect repeated states can turn a linear problem into an exponential one! 29

29 Avoiding loops Method 1: Don t add a node to the fringe if we generated a node for the associated state before What if there are multiple paths to a node and we want to be sure to get the shortest? Method 2: Graph search Don t add a node to the fringe if we expanded a node for the associated state before Keep a closed (=explored=visited) list of expanded states (c.f. Dijkstra) This is not for free: takes up time and memory! 30

30 Search strategies A search strategy defines the order of node expansion Strategies are evaluated along the following dimensions: completeness: does it always find a solution if one exists? optimality: does it always find a least cost solution? time complexity: how long does it take to find a solution? space complexity: how much memory is needed? Time and space complexity are measured in terms of b: maximum branching factor of the search tree (max # succ.) d: depth of the least cost solution (start with d=0) m: maximum length of path in state space (may be ) total number of nodes generated (= time) maximum number of nodes in memory (= space) Solution quality Search complexity 32

31 Uninformed search strategies Use only the information available in the problem definition (a.k.a. blind search) Breadth first search Uniform cost search Depth first search Depth limited search Iterative deepening search (BFS) (UCS) (DFS) (DLS) (IDS) Can only generate successors and distinguish goalstate from non goal state 33

32 Breadth-first search Expand shallowest unexpanded node Implementation: fringe is a FIFO queue, i.e., new successors go at end ties:(in this case) queue in alphabetical order fringe = A 34

33 Breadth-first search Expand shallowest unexpanded node Implementation: fringe is a FIFO queue, i.e., new successors go at end ties:(in this case) queue in alphabetical order fringe = BC 35

34 Breadth-first search Expand shallowest unexpanded node Implementation: fringe is a FIFO queue, i.e., new successors go at end ties:(in this case) queue in alphabetical order fringe = CDE 36

35 Breadth-first search Expand shallowest unexpanded node Implementation: fringe is a FIFO queue, i.e., new successors go at end ties:(in this case) queue in alphabetical order fringe = DEFG 37

36 Properties of BFS Assumption: goal test upon generation, finite d Complete? Yes, as long as b is finite Optimal? Yes, if step costs equal shallowest == optimal Time? 1+b+b 2 +b 3 + +b d = O(b d ) (if goal test upon expansion: + b(b d 1) = O(b d+1 )) Space? same as time dominate costs for closed list in graph search Exponential space is bigger problem (even more than time) works only for smaller instances 38

37 Uniform-cost search Expand least cost unexpanded node Like Dijkstra, but now with goal test Implementation: fringe = priority queue, ordered by path cost g(n) Equivalent to breadth first search if step costs all equal! But step costs need not be equal (even though the name may suggest otherwise)! 39

38 Properties of UCS Assumption: finite d; ε = minimal step cost; C* = cost of cheapest solution Complete? Yes, if ε > 0 and b is finite Optimal? Yes: nodes expanded in increasing order of g(n) Time? O(b ceiling(c*/ ε) ) (# of nodes with path cost g C * ) Space? O(b ceiling(c*/ ε) ) typically dominate costs for closed list in graph search 40

39 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = A 41

40 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = BC 42

41 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = DEC 43

42 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = HIEC 44

43 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = IEC done at H 45

44 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = EC done at I done at D 46

45 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = JKC 47

46 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = KC done at J 48

47 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = C done at K done at E done at B 49

48 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = FG 50

49 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = LMG 51

50 Depth-first search Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front ties:(in this case) stack in reverse alphabetical order fringe = MG Etc. done at L 52

51 Properties of DFS Complete? No, unless graph search in finite state space, finite d Optimal? No, it finds left most solution, regardless of cost Time? O(b m ) terrible if m is much larger than d but if solutions are dense, may be much faster than breadth first Space? O(bm), in case of tree search ( black nodes are removed from memory) Advantage may be lost in graph search due to costs for closed list! 53

52 Depth-limited search = depth first search with depth limit l, i.e., nodes at depth l do not generate successors solves infinite path problem (m = ) Recursive implementation: 54

53 Properties of DLS Note: DFS is special case of DLS with l = m (possibly ) Complete? Not if l < d (do we know d??) Optimal? Not if d < l Time? O(b l ) Space? O(bl) Again advantage may be lost in graph search due to costs for closed list! 55

54 Iterative deepening search Repeats DFS for increasing depth limit Finds best depth limit Combines benefits of BFS and DFS 56

55 Iterative deepening search limit=0 57

56 Iterative deepening search limit=1 58

57 Iterative deepening search limit=2 59

58 Iterative deepening search limit=3 60

59 Iterative deepening search Number of nodes generated in a depth limited search (DLS) 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 (ITS) 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% 61

60 Assumption: finite d Properties of IDS Complete? Yes Optimal? Yes Inherited from BFS; same assumptions apply Time? O(b d ) (d+1)b 0 + d b 1 + (d 1)b b d Space? O(bd) Inherited from DFS, but max depth restricted to d; same observations wrt graph search apply 62

61 Summary of search algorithms This overview assumes tree search, with goal test upon expansion, and finite solution depth d. Recall (!): most yes s and no s depend on additional assumptions Space complexity may be different if graph search is employed Is there one best algorithm? 63

62 Summary pathfinding and uninformed search Algorithms find path to goal Problem specific ingredients used only for: Goal test Path cost (used in solution, and sometimesfor expansion) 64