Solving Problems by Searching. Artificial Intelligence Santa Clara University 2016

Transcription

1 Solving Problems by Searching Artificial Intelligence Santa Clara University 2016

2 Problem Solving Agents Problem Solving Agents Use atomic representation of states Planning agents Use factored or structured states Uninformed search algorithms Algorithms only use state space Informed search algorithms Algorithms use some guidance where to find solution

3 Problem Solving Agents Problem formulation What actions and state to consider Goal formulation What is a desirable state

4 Problem Solving Agents First set of assumptions Environment is observable Agent knows current state Environment is discrete In any state, there are only a finite number of actions to be taken (and states to be reached) Environment is known Agent knows which states are reached by what action Environment is deterministic Each action has exactly one outcome

5 Problem solving agents Search: Looking for a sequence of actions that lead to the (a) goal Execution: Follow the sequence of actions Formulate - Search - Execute Notice: agent does not react to precepts during the execute phase Open loop system: loop between agent and environment is broken

6 Problem Solving Agents Well-defined problem 1. Initial state 2. Descriptions of actions 3. Transition model: Which action leads to what state 4. Goal test 5. Path cost

7 Recurring Sample Problem: Navigating Rumania 71 Oradea Neamt Zerind 140 Timisoara Fagaras 80 Rimnicu Vilcea 87 Iasi 92 Vaslui 111 Lugoj 97 Pitesti Drobeta Mehadia Bucharest 90 Craiova Giurgiu 98 Urziceni Hirsova 86 Eforie

8 A typical toy problem L R L R S S R R L R L R L L S S S S R L R L S S

9 Another toy problem Start State Goal State

10 Another toy problem

11 A simple real world problem Find a flight from A to B (with stop overs)

12 Uninformed Searching Uninformed searching Go through the search space looking for a state that fulfills the goal condition Search space represented as a graph of nodes Expand nodes (create all the neighbors of the current node)

13 Uniformed Searching State examples: 8-puzzle State given by a matrix with entries represents the blank space Note: for half of the initial states, there is no solution _goal_state = [[1,2,3], [4,5,6], [7,8,0]]

14 Uninformed Searching n - queens problem States are given by the position of j queens Each queen needs to be in a different column State given by an array (Python list) of j numbers Avoid generating states that are not legal def init (self, parent, move): self.parent = parent if parent: self.lista = parent.lista[:] else: self.lista = [] self.lista.append(move) def str (self): return "State "+str(self.lista) def test(self): #test whether any queen can take another one for col in range(0,len(self.lista)): row = self.lista[col] for j in range(len(self.lista)): if j == col: continue if self.lista[j] == row+j-col or self.lista[j] == row-j+col: return False return True

15 Uninformed Searching When generating nodes, can revisit the same node Repeated state Loopy path Search tree is then infinite, even though state space is finite Assuming going from one state to another incurs costs Assuming costs add up Then loopy paths never are cost-optimal

16 Uninformed Searching (a) (b) (c) Black: explored set discovered and expanded White: frontier discovered but not yet expanded Gray: unknown set not yet discovered

17 Example 71 Oradea Neamt Breadth first search: حفظنا اهلل منه Generate all accessible nodes in order until finding goal state Zerind 140 Timisoara Drobeta Fagaras 80 Rimnicu Vilcea Lugoj Mehadia 120 Pitesti Bucharest 90 Craiova Giurgiu 87 Iasi Urziceni Vaslui Hirsova 86 Eforie

18 Uninformed Searching Breadth first search Finds guaranteed a goal state if there is a path to the goal state Expand initial state, then the states expanded from it, then the states expanded from them, def bfs(instance): states = fifo(instance.initial) while states: current = states.pop(0) else: for state in current.neighbours(): if state.notmarked() and state.feasible(): if state.isgoal(): return state state.markvisited() states.append(state)

19 Uninformed Search BFS: Will find closest goal node Assume a branching factor of b Number of unexplored nodes reachable from a node during the breadth-first search Assume nearest goal state is at distance d from the initial state BFS creates b + b 2 + b b d = O(b d ) nodes

20 Uninformed Search BFS: Memory is stressed: too many nodes kept in fifo queue Time needs depends on the depth of the search

21 Uninformed Search Uniform cost search: Assume that all state transitions incur a cost g(node) = cost to reach node from initial node Expand the node n with the lowest path cost g(n) Apply goal test only when the node is expanded

22 Uninformed Search def uniformcostsearch(instance): frontier = priorityqueue(instance.initial, 0) explored = [] while frontier: current = frontier.pop() #get lowest cost node if current.isgoal(): print(current) #print out inverse path to goal for node in current.neighbours(): node.parent = current pathcost = current.cost + current.actioncost(node) if node in frontier and node.cost > pathcost: node.cost = pathcost #duplicate, update node.parent = current elif node not in frontier and node not in explored: frontier.insert(node) explored.append(current)

23 Group Quiz Apply Uniform Cost Search to go from to Bucharest 71 Oradea Neamt Zerind 140 Timisoara Fagaras 80 Rimnicu Vilcea 87 Iasi 92 Vaslui 111 Lugoj 97 Pitesti Drobeta Mehadia Bucharest 90 Craiova Giurgiu 98 Urziceni Hirsova 86 Eforie

24 Uninformed Search Depth First Search: Use stack instead of fifo in organizing the frontier def dfs(instance): states = lifo(instance.initial) while states: current = states.pop(0) else: for state in current.neighbours(): if state.notmarked() and state.feasible(): if state.isgoal(): return state state.markvisited() states.append(state)

25 Uninformed Search DFS will find a solution more quickly if they are lots of solutions at a certain depth. n-queens problem: n bfs dfs

26 Uninformed Search A A A B C B C B C D E F G H I J K L M N O D E F G H I J K L M N O D E F G H I J K L M N O A A A B C B C C D E F G H I J K L M N O D E F G I J K L M N O E F G J K L M N O A A C B C C E F G E F G F G J K L M N O K L M N O L M N O A A A C C C DFS on a F G L M N O F G L M N O F G M N O binary tree

27 Uninformed Search DFS works well if there are goal states at a limited depth but horribly if there are not Depth limited search If you don t find a goal, break off after reaching a maximum depth of d How do we determine d? Sometimes, the problem can tell us Iterative deepening depth first search

28 Uninformed Search Iterative deepening depth first search Do limited depth dfs Increase limit, if no solution found Why is this a good idea? We recreate parts of the previous search tree Repeated work is not a big portion of the total work done db +(d 1)b 2 +(d 2)b b d 1 +1b d = O(b d )

29 Uninformed Search Bidirectional Search Basic idea: Search from the initial state and from the goal state Success if you can connect Complexity O(bˆd/2) Start Goal

30 Informed Searches Use additional information Rumanian road map: Straight-line distance to goal 8-puzzle Sum of the Manhattan distance of current location of a piece to goal location of a piece n-queen problem Need to redefine states

31 Informed Search Tree search Expand nodes without regard whether expanded nodes have been visited Graph search Expand nodes but disregard explored nodes

32 Informed Search def treesearch(instance): frontier = [ instance.initial ] while frontier: current = frontier.pop() if current.isgoal(): return current else: for node in current.neighbor() node.parent = current frontier.push(node)

33 Informed Search def graphsearch(instance): explored = [] frontier = [instance.initial] while frontier: current = frontier.pop() if current.isgoal(): print( current ) explored.push(current) for node in current.neighbor(): if node not in explored and node not in frontier: node.parent = current frontier.push(node)

34 Informed Search Best-first search Do graph search Use a priority queue Have an evaluation function for each node

35 Informed Search Greedy first search: Expand nodes according to the best node Example: Use straight-line distance to the goal Bucharest Craiova Drobeta Eforie Fagaras Giurgiu Hirsova Iasi Lugoj Mehadia Neamt Oradea Pitesti Rimnicu Vilcea Timisoara Urziceni Vaslui Zerind

36 Informed Search (a) The initial state (b) After expanding 366 Timisoara Zerind (c) After expanding Timisoara 329 Zerind 374 Fagaras Oradea Rimnicu Vilcea (d) After expanding Fagaras Timisoara Zerind Fagaras Oradea Rimnicu Vilcea Bucharest 253 0

37 Informed Search Greedy best first search has difficulties Going from Iasi to Fagaras First expand Neamt This puts Iasi back into the frontier Can never consider Vaslui, because Vaslui is farther from Fagaras according to the heuristics Oradea 71 Neamt Zerind Fagaras 80 Timisoara Rimnicu Vilcea 111 Lugoj 70 Mehadia 75 Drobeta 120 Pitesti Bucharest 90 Craiova Giurgiu 87 Iasi Urziceni Vaslui Hirsova 86 Eforie

38 Informed Search Greedy best-first search Combine with graph search algorithm Do not consider repeated states Version is complete for finite trees

39 Informed Search A* search Evaluation function f for node n: g(n) cost of getting to node n h(n) heuristic for getting from node n to goal f(n) =g(n)+h(n)

40 Informed Search A* search When will A* be optimal? Heuristic needs to be admissible Never overestimate the costs to reach the goal from the current node Heuristic needs to be consistent (when using graph search) Estimated costs of reaching goal from n is less than or equal to the costs of going from n to successor n plus estimated costs of reaching the goal from n. 8n, 8n 0,n 0 successor of n h(n) apple costs(n, n 0 )+h(n 0 )

41 Informed Search Tree-version of A* is optimal if heuristic is admissible Graph version of A* is optimal if heuristic is consistent Clue: f-costs are nondecreasing on any path generated Can "prune" even neighbors of initial node

42 (a) The initial state (b) After expanding 366= = Timisoara 447= Zerind 449= (c) After expanding Timisoara Zerind 447= = Fagaras Oradea Rimnicu Vilcea 646= = = = (d) After expanding Rimnicu Vilcea Timisoara Zerind 447= = Fagaras Oradea 646= = = Rimnicu Vilcea Craiova Pitesti 526= = = (e) After expanding Fagaras Timisoara Zerind 447= = Fagaras Oradea Rimnicu Vilcea 646= = Bucharest Craiova Pitesti 591= = = = = (f) After expanding Pitesti Timisoara Zerind 447= = Fagaras Oradea Rimnicu Vilcea 646= = Bucharest Craiova Pitesti 591= = = = Bucharest Craiova Rimnicu Vilcea 418= = =

43 Informed Search A* expands nodes according to contours O Z N A T 380 S 400 R L F P I V D M C 420 G B U H E

44 Informed Search A* works well If there are many sub-optimal paths that are not quite a goal, then A* will explore many unnecessary spaces

45 Informed Search A* problems A* needs to maintain big arrays it never throws away a node runs out of memory before it runs out of user s patience

46 Informed Search Memory bounded A* variants Iterative deepening Cut-off consideration of nodes with f-value larger than a certain value If not successful, adjust cut-off point Can be difficult if f-values are floats

47 Informed Search Recursive best-first search Uses only linear space Uses an f-limit value to keep track of the best alternative path available

48 Informed Search RBFS Search f_limit on top heuristic on bottom (a) After expanding,, and Rimnicu Vilcea Fagaras Oradea Rimnicu Vilcea (b) After unwinding back to and expanding Fagaras Fagaras Oradea Rimnicu Vilcea Craiova Pitesti Timisoara Zerind Timisoara 447 Zerind Bucharest 450 (c) After switching back to Rimnicu Vilcea and expanding Pitesti Timisoara 447 Zerind Fagaras Oradea Rimnicu Vilcea Craiova Pitesti Bucharest Craiova Rimnicu Vilcea

49 Informed Search RBFS Search (a) Expand on best path unless the current best leaf (Pitesti) is worse than the best alternative value (Fagaras) Don t forget to update the value for Rimicu Vilcea (a) After expanding,, and Rimnicu Vilcea Fagaras Oradea Rimnicu Vilcea Fagaras Oradea Bucharest (b) After unwinding back to and expanding Fagaras 393 Rimnicu Vilcea (c) After switching back to Rimnicu Vilcea and expanding Pitesti Craiova Pitesti Timisoara Zerind Timisoara Zerind Timisoara 447 Zerind Fagaras Oradea Rimnicu Vilcea Craiova Pitesti Bucharest Craiova Rimnicu Vilcea

50 Informed Search RBFS Search (b) Unwind to This puts the best leaf value of the forgotten subtree in Rimnicu Vilcea. Expand Fagaras with best leaf value of 450 (a) After expanding,, and Rimnicu Vilcea Fagaras Oradea Rimnicu Vilcea (b) After unwinding back to and expanding Fagaras Fagaras Oradea Rimnicu Vilcea Craiova Pitesti Timisoara Zerind Timisoara 447 Zerind Bucharest 450 This is worse than 415 for Rimnicu Vilcea (c) After switching back to Rimnicu Vilcea and expanding Pitesti Fagaras Oradea Rimnicu Vilcea Craiova Pitesti Timisoara Zerind Bucharest Craiova Rimnicu Vilcea

51 Informed Search RBFS Search (c) Back up to after updating Fagaras Expand again RV Then expand Pitesti This time, we reach Bucharest, because the best alternative value (Timisoara) is worse (a) After expanding,, and Rimnicu Vilcea Fagaras Oradea Rimnicu Vilcea Fagaras Oradea Bucharest (b) After unwinding back to and expanding Fagaras Fagaras Oradea Rimnicu Vilcea (c) After switching back to Rimnicu Vilcea and expanding Pitesti Craiova Pitesti Rimnicu Vilcea Craiova Pitesti Timisoara Zerind Timisoara Zerind 449 Timisoara Zerind Bucharest Craiova Rimnicu Vilcea

52 Informed Search RBFS generates less nodes than IDA* In a sense, IDA* and RBFS throw away too much memory

53 Informed Search Memory bounded A* Simplified memory bounded A*

54 Informed Search Simplified memory bounded A* Do A* until algorithm runs out of memory Need to free a node Frees the node with the highest value of f After backing up the f-value to its parent If all the descendants of n are forgotten SMA* does not know where to go from n But SMA* knows whether n is worth while considering

55 Heuristics Example 8-puzzle Branching factor about 3 Depth about 22 Exhaustive tree search gives 3**22 ~3*10**10 moves Graph search has 9!/2 possible states Example 15-puzzle Graph search has 16!/2 = 10,461,394,944,000 states

56 Heuristics Heuristic may not overstate the true costs of moving to the goal state 1. Use number of misplaced tiles 2. Use the sum of the Manhattan distances of tiles in the actual state to the tiles in the goal state Start State Goal State

57 Heuristics 8-puzzle Second choice works better

58 Heuristics Relaxed search problems Instead of humans inventing heuristics Computer could generate heuristics by relaxing the rules of the game 8 puzzle: Allow tiles move to any position Second heuristic gives the costs to move to the goal in the relaxed version Automatic generation of heuristics Formulate the rules of the game Then relax automatically the rules Try out heuristics

59 Heuristics Pattern databases: Generate admissible heuristics from subproblems Start State Goal State Heuristic: Costs of moving 1,2,3,4 to a goal state

60 Heuristics Pattern databases: Use various heuristics 1,2,3,4 5,6,7,8 Pattern database stores the exact solution for a number of subproblems Disjoint pattern database Solve 1, 2, 3, 4 subproblem only counting the moves of tiles 1, 2, 3, or 4 Solve 5, 6, 7, 8 subproblem only contain the moves of tiles 5, 6, 7, or 8 Heuristic is the sum of both values