ARTIFICIAL INTELLIGENCE

Transcription

1 3010 ARTIFICIAL INTELLIGENCE Lecture 4 Iterative Deepening A* Masashi Shimbo

2 Depth-first search Recursive implementation Depth-first search can be implemented in a recursive fashion 2 / 44

3 Depth-first search vanilla depth-first search, recursive implementation 1 function DFS(v) Input Output : node v to start depth-first search : a goal node, if found, or failure 2 if IsGoal(v) then return v # if a goal is found, return it 3 foreach u Succ(v) do 4 Parent[u] v # memorize parent of u 5 result DFS(u) # traverse u 6 if result failure then return result 7 remove Parent[u] from memory # no goal below u; so forget u 8 return failure 3 / 44

4 IDA*: Iterative Deepening A* 4 / 44

5 A*: problem with memory consumption A*, if guided by a good heuristic, focuses search towards goals. It can generate fewer nodes than Dijkstra s algorithm. But memory consumption may still be huge since A* keeps all generated nodes on memory. (E.g., 24-puzzles with the Manhattan heuristic) 5 / 44

6 Heuristic search + Iterative deepening depth-first search 6 / 44

7 IDA*: Iterative-Deepening A* A memory-efficient heuristic search method A heuristic version of iterative deepening depth-first search 7 / 44

8 Iterative deepening depth-first search for trees Depth-first search might not terminate in an infinte state space. Iterative deepening depth-first search overcomes this difficulty by introducing a cutoff depth θ to depth-first search backtrack immediately if the node depth exceeds θ; successively running depth-first searches with increasing cutoff depth θ = 1, 2,... 8 / 44

9 Iterative deepening depth-first search initial state goal state unbounded path 9 / 44

10 Iterative deepening depth-first search initial state Cutoff depth = 1 No goal states with depth less than or equal to 1 epth-first search fails. goal state unbounded path 10 / 44

11 Iterative deepening depth-first search initial state Cutoff depth = 2 No goal states with depth less than or equal to 2 epth-first search fails. goal state unbounded path 11 / 44

12 Iterative deepening depth-first search initial state Cutoff depth = 3 A goal state exists at depth 3. epth-first search succeeds. goal state unbounded path 12 / 44

13 Depth-first search vanilla depth-first search, recursive implementation 1 function DFS(v) Input Output : node v to start depth-first search : a goal node, if found, or failure 2 if IsGoal(v) then return v # if a goal is found, return it 3 foreach u Succ(v) do 4 Parent[u] v # memorize parent of u 5 result DFS(u) # traverse u 6 if result failure then return result 7 remove Parent[u] from memory # no goal below u; so forget u 8 return failure 13 / 44

14 Depth-first search depth-bounded version for iterative deepening 1 function DFS(v, θ) Input Output : node v to start depth-first search : cut-off depth θ : a goal node, if found, or failure 2 if IsGoal(v) then return v # if a goal is found, return it 3 foreach u Succ(v) do 4 if Depth[v] + 1 θ then # if the depth of u does not exceed cutoff θ 5 Depth[u] Depth[v] + 1 # memorize depth of v 6 Parent[u] v # memorize parent of u 7 result DFS(u) # traverse u 8 if result failure then return result 9 remove Parent[u] and Depth[u] from memory 10 return failure # no goal below u; so no need to keep information about u 14 / 44

15 Iterative deepening depth-first search main controller Calls the depth-bounded DFS function repeatedly until a goal is found, gradually increasing the cutoff depth θ. Input Output : initial state s : a goal node, if found 1 θ 0 2 Depth[s] 0 3 loop do 4 result DFS(s, θ) 5 if result failure then return result 6 θ θ / 44

16 Designing heuristic depth-first search applicable to general state spaces How do we deal with cycles/multiple paths to a node? How do we take costs into account? How do we use heuristic functions with depth-first search? 16 / 44

17 Designing heuristic depth-first search applicable to general state spaces How do we deal with cycles/multiple paths to a node? How do we take costs into account? How do we use heuristic functions with depth-first search? 17 / 44

18 s s a d c b a d t a c b t If there is a cycle in the state space, the corresponding search tree may be infinite and vanilla depth-first search may not terminate. s a b c a b c a 18 / 44

19 Cyclic path elimination In depth-first search, easiest way to eliminate cyclic paths is to maintain the list of nodes in the current path (from the initial node). Do not follow a path if it is found to be cyclic. s a b c a b c a And/or use iterative deepening depth-first search. 19 / 44

20 Avoid depth-first search/ida* if the state-space graph contains a lot of paths to the same nodes Why? Depth-first search/ida* may perform poorly Even with the cycle elimination technique, if there are multiple paths from s to a node, the node may be visited repeatedly. Revisiting unavoidable unless all generated nodes are kept on memory just like Dijkstra/A* In essence: With depth-first search, we are trading off space with runnning time 20 / 44

21 Designing heuristic depth-first search applicable to general state spaces How do we deal with cycles/multiple paths to a node? How do we take edge costs into account? How do we use heuristic functions with depth-first search? 21 / 44

22 Designing heuristic depth-first search applicable to general state spaces How do we deal with cycles/multiple paths to a node? How do we take edge costs into account? How do we use heuristic functions with depth-first search? 22 / 44

23 Incorporating edge costs into iterative deepening depth-first search Use cutoff costs in place of cutoff depths. 23 / 44

24 Incorporating edge costs into iterative deepening depth-first search Use cutoff costs in place of cutoff depths. Issue: In iterative deepening depth-first search, cutoff depth θ is increased by one after each unsuccessful depth-bounded DFS. If θ represents a cutoff cost, what increment should be added after each iteration? 24 / 44

25 Iterative deepening depth-first search using depth-bounded DFS Input Output : initial node s : a goal node, if found 1 θ 0 2 Depth[s] 0 3 loop do 4 result DFS(s, θ) 5 if result failure then return result 6 θ θ / 44

26 Iterative deepening depth-first search using cost-bounded DFS Input Output : initial node s : a goal node, if found 1 θ 0 2 g[s] 0 3 loop do 4 result DFS(s, θ) 5 if result failure then return result 6 θ θ / 44

27 Iterative deepening depth-first search using cost-bounded DFS Input Output : initial node s : a goal node, if found 1 θ 0 2 g[s] 0 3 loop do 4 result DFS(s, θ) 5 if result failure then return result 6 θ θ +? 27 / 44

28 What increment should be added to the cutoff cost? Solution: When the g-value of a generated node exceeds the current cutoff θ, search is cut off at the node (just as before). Among these cutoff nodes at which g > θ, find the minimum g-value. Use the minimum value as the cutoff for the next iteration. 28 / 44

29 Function DFS depth-bounded version 1 function DFS(v, θ) Input Output 2 if IsGoal(v) then return v 3 foreach u Succ(v) do 4 d Depth[v] + 1 : v = node to start depth-first search : θ = cut-off depth : goal node, if found, or failure 5 if d θ then # if the depth of v does not exceed cutoff θ 6 Parent[u] v; Depth[u] d # memorize the parent and depth of u 7 result DFS(u, θ) # traverse u 8 if result failure then return result # if a goal is found, return it 9 remove Parent[u] and Depth[u] from memory 10 return failure 29 / 44

30 Function DFS cost-bounded version 1 function DFS(v, θ) Input Output 2 if IsGoal(v) then return v 3 foreach u Succ(v) do 4 d g[v] + c(v, u) : v = node to start depth-first search : θ = cut-off cost : goal node, if found, or failure 5 if d θ then # if the g-value of v does not exceed cutoff θ 6 Parent[u] v; g[u] d # memorize the parent and g-value of u 7 result DFS(u, θ) # traverse u 8 if result failure then return result # if a goal is found, return it 9 remove Parent[u] and g[u] from memory 10 return failure change Depth to g 30 / 44

31 Function DFS cost-bounded version 1 function DFS(v, θ, θ next ) Input Output 2 if IsGoal(v) then return v 3 foreach u Succ(v) do 4 d g[v] + c(v, u) : v = node to start depth-first search : θ = cut-off cost : θ next = best g-value among cutoff nodes found so far : a pair result, θ next where : result = goal node, if found, or failure : θ next = updated best g-value among cutoff nodes 5 if d θ then # if the depth of v does not exceed cutoff θ 6 Parent[u] v; g[u] d # memorize the parent and g-value of u 7 result, θ next DFS(u, θ, θ next ) # traverse u 8 if result failure then return result, nil # if a goal is found, return it 9 remove Parent[u] and g[u] from memory 10 else if d < θ next then θ next g[u] # maintain least g-value among cutoff nodes 11 return failure, θ next change Depth to g changes to compute θ next 31 / 44

32 Iterative deepening depth-first search original version not taking costs into account Input Output : initial state s : a goal node, if found 1 θ 0 2 Depth[s] 0 3 loop do 4 result DFS(s, θ) 5 if result failure then return result 6 θ θ / 44

33 Iterative deepening depth-first search cost-sensitive version Input Output : initial state s : a goal node, if found 1 θ 0 2 g[s] 0 3 loop do 4 result, θ next DFS(s, θ, ) 5 if result failure then return result 6 θ θ next 33 / 44

34 Cost-sensitive iterative deepening depth-first search is complete and admissible 34 / 44

35 Designing heuristic depth-first search applicable to general state spaces How do we deal with cycles/multiple paths to a node? How do we take edge costs into account? How do we use heuristic functions with depth-first search? 35 / 44

36 Designing heuristic depth-first search applicable to general state spaces How do we deal with cycles/multiple paths to a node? How do we take edge costs into account? How do we use heuristic functions with depth-first search? 36 / 44

37 IDA*: iterative deepening search with heuristic functions Cutoff θ now limits f [v] = g[v] + h(v) instead of g[v] 37 / 44

38 Function DFS cost-bounded version 1 function DFS(v, θ, θ next ) Input Output 2 if IsGoal(v) then return v 3 foreach u Succ(v) do : v = node to start depth-first search : θ = cut-off cost : θ next = best g-value among cutoff nodes so far : a pair result, θ next where : result = goal node, if found, or failure : θ next = best g-value among cutoff nodes 4 d g[v] + c(v, u); # compute g[u] 5 if d θ then # if d does not exceed cutoff 6 Parent[u] v; g[u] d # memorize the parent and g-value of u 7 result, θ next DFS(u, θ, θ next ) # traverse u 8 if result failure then return result, nil # if a goal is found, return it 9 remove Parent[u] and g[u] from memory 10 else if d < θ next then θ next d # maintain least g-value among cutoff nodes 11 return failure, θ next 38 / 44

39 Function DFS cost-bounded version 1 function DFS(v, θ, θ next ) Input Output 2 if IsGoal(v) then return v 3 foreach u Succ(v) do : v = node to start depth-first search : θ = cut-off cost : θ next = best f -value among cutoff nodes so far : a pair result, θ next where : result = goal node, if found, or failure : θ next = best f -value among cutoff nodes 4 d g[v] + c(v, u); f d + h(u) # compute g[u] and f [u] 5 if f θ then # if f [u] does not exceed cutoff 6 Parent[u] v; g[u] d # memorize the parent and g-value of u 7 result, θ next DFS(u, θ, θ next ) # traverse u 8 if result failure then return result, nil # if a goal is found, return it 9 remove Parent[u] and g[u] from memory 10 else if f < θ next then θ next f # maintain least f -value among cutoff nodes 11 return failure, θ next 39 / 44

40 Iterative deepening depth-first search main controller Input Output : initial state s : a goal node, if found 1 θ 0 2 g[s] 0 3 loop do 4 result, θ next DFS(s, θ, ) 5 if result failure then return result 6 θ θ next 40 / 44

41 Iterative deepening A* main controller Input Output : initial state s : a goal node, if found 1 θ h(s) # in IDA*, θ bounds f, not g 2 g[s] 0 3 loop do 4 result, θ next DFS(s, θ, ) 5 if result failure then return result 6 θ θ next 41 / 44

42 IDA* is complete and admissible provided that h is admissible Benign memory footprint (required amount of memory linear in the depth of goals) 42 / 44

43 Search strategies Uninformed search Uninformed search Heuristic search Edge costs Breadth-first family Depth-first family Identical Breadth-first search (Iterative deepening) depth-first search Non-identical Dijkstra s algorithm IDA* with h = 0 Non-identical A* IDA* 43 / 44

44 Two heuristic (informed) search strategies A* IDA* severe memory requirement keeps all generated nodes benign memory footprint might be a good choice for huge graphs but inefficient in a graph in which many paths to nodes exists (lattice, etc.) 44 / 44