Solving problems by searching

Transcription

1 Solving problems by searching Based on: Stuart Russell, Peter Norvig, Articial Intelligence: A Modern Approach, 2009 Katadra Automatyki Akademia Górniczo-Hutnicza spring 2011 (KA AGH) spring / 70

2 Lecture Plan 1 The algorithm The algorithm 2 Graph as a model of the Search Space 3 Blind search strategies 4 Informed search strategies 5 (KA AGH) spring / 70

3 We dene a problem by providing: State space S. Initial state s I S. Actions available within given state. a Goal test or goal state s G S. b Cost function γ, Forbidden states F S. a Usually dened as so-called successor function which, for a given state, returns the set of available actions. b Explicit (designated state) or implicit (goal satisfaction solutions). Formal problem denition A problem P is dened as six-tuple: P = (S, s I, s G, F, O, γ). (KA AGH) spring / 70

4 State-Space and Problem Solution State-Space A state-space is a set of potential/feasible/legal states of some system. A state-space can be discrete (nite) or continuous. States A state representes local description of a system which is: complete, consistent, minimal. Problem solution For P = (S, s I, s G, F, O, γ) its solution is dened by a sequnece (o 1, o 2,..., o n ), such that: o 1 (s I ) = s 1, o 2 (s 1 ) = s 2,..., o n (s n 1 ) = s G Induced sequnece of states s I = s 0, s 1, s 2,..., s n = s G. (KA AGH) spring / 70

5 Example: a trip to Romania Example problem statement We are in Arad in Romania. Our plane leaves tomorrow from Bucharest. Problem statement State space: distingushed cities Initial state: Arad Available actions: travel to another city (see map) Goal test: Are we in Bucharest? or Goal state: Bucharest Cost function: sum of road lengths to given city Forbidden states: optional (KA AGH) spring / 70

6 Map of Romania 71 Oradea Zerind 75 Arad Timisoara Dobreta Neamt Iasi 92 Sibiu 99 Fagaras Vaslui 80 Rimnicu Vilcea 142 Lugoj Pitesti Hirsova Mehadia Urziceni Bucharest Craiova Eforie Giurgiu (KA AGH) spring / 70

7 7 5 8 Example: 8-puzzle 2 3 Start State Problem statement Goal State State space: all possible combinations of tile locations Initial state: any of the above states Available actions: legal moves (from: Left, Right, Up, Down) Goal test: are all tiles in order? Cost function: number of steps in path (KA AGH) spring / 70

8 Example State-Space Search Problems Toyproblems Missionaries and cannibals, Towers of Hanoi, Block World, Criptoarithmetic problems, N-queens problem. More serious applications Route planning, Agent action planning, Robot navigation, Symbolic integration, term rewriting, Conguration, assembly, package planning. (KA AGH) spring / 70

9 State space vs. search tree The dierence State space represents the states of the search space. Search tree shows how we proceed within the state space. A node in the search tree consists of: state to which it corresponds, parent node which generated (among others) this node, action applied to generate this node, path cost g(n) from initial state to this node, depth, i.e. number of steps from initial state. (KA AGH) spring / 70

10 Tree search Informal algorithm Basic idea: offline, simulated exploration of state space by generating successors of already-explored states (a.k.a. expanding states) function ( problem, strategy) returns a solution, or failure initialize the search tree using the initial state of problem loop do if there are no candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree end Chapter 3 25 (KA AGH) spring / 70

11 Important denitions Search strategy Decides, which node (among those determined by available actions) is expanded next. Fringe (frontier) Queue of nodes to be expanded. (KA AGH) spring / 70

12 Evaluation of search Completeness Is the algorithm guaranteed to nd a solution if one exists? Optimality When the algorithm nds a solution, is this the optimal one? Time complexity How long does it take to nd a solution? a a Often measured as number of nodes generated during search. Space complexity How much memory is needed to perform the search? a a Often measured as maximum number of nodes stored in memory. (KA AGH) spring / 70

13 Implementation: The general algorithm tree search Implementation: general tree search function ( problem, fringe) returns a solution, or failure function fringe ( Insert(Make-Node(Initial-State[problem]), problem, fringe) returns a solution, or fringe) failure fringe loop do Insert(Make-Node(Initial-State[problem]), fringe) loopifdofringe is empty then return failure if node fringe Remove-Front(fringe) is empty then return failure node if Goal-Test(problem, Remove-Front(fringe) State(node)) then return node if fringe Goal-Test(problem, InsertAll(Expand(node, State(node)) then problem), return fringe) node fringe InsertAll(Expand(node, problem), fringe) function Expand( node, problem) returns a set of nodes function successors Expand( thenode, empty problem) set returns a set of nodes successors for each action, the empty resultset in Successor-Fn(problem, State[node]) do for each s aaction, new Node result in Successor-Fn(problem, State[node]) do s Parent-Node[s] a new Node node; Action[s] action; State[s] result Parent-Node[s] node; Action[s] action; State[s] result Path-Cost[s] Path-Cost[node] + Step-Cost(node, action, s) Path-Cost[s] Path-Cost[node] + Step-Cost(node, action, s) Depth[s] Depth[node] + 1 Depth[s] Depth[node] + 1 add s to successors add s to successors return successors return successors (KA AGH) spring / 70

14 Problems Solution A B C D Avoiding repeated states Loops (solution: remember path). Innite paths (solution: limit cost). Repeated search of nodes (solution: store all nodes). C Any algorithm that forgets its history is doomed to repeat it. Modify the algorithm to include a so-called closed list, storing every expanded node. The new algorithm is called. B C A C B C (KA AGH) spring / 70

15 The algorithm Graph search function ( problem, fringe) returns a solution, or failure closed an empty set fringe Insert(Make-Node(Initial-State[problem]), fringe) loop do if fringe is empty then return failure node Remove-Front(fringe) if Goal-Test(problem, State[node]) then return node if State[node] is not in closed then add State[node] to closed fringe InsertAll(Expand(node, problem), fringe) end (KA AGH) spring / 70

16 Lecture Plan 1 2 Graph as a model of the Search Space 3 Blind search strategies 4 Informed search strategies 5 (KA AGH) spring / 70

17 Basic intuitive formulation of a graph A graph is a set of nodes (vertices) interconnected with links (edges). A graph is a model of a search space. (KA AGH) spring / 70

18 Formal denitions of a graph I Denition: Simple Directed Graph V a nite set of vertices (or nodes), V = {v 1, v 2,..., v n }, E a nite set of edges (or links); E V V. A simple directed graph G is dened as G = (V, E). Denition: Directed Graph A directed graph G is any four-tuple G = (V, E, α, ω) α: E V is a function dening the starting point of an edge, ω is a function ω : E V dening the end point of an edge. (KA AGH) spring / 70

19 Formal denitions of a graph II Denition: Undirected Graph An undirected graph G is any triple G = (V, E, λ) where λ is a function of the form λ: E V 2, V 2 = {{v i, v j }: v i, v j V } dening the endpoints for an edge. a a An alternative denition is also possible: G = (V, E, λ), λ : E V 2 ; however, the denition used is more appropriate for further statements. (KA AGH) spring / 70

20 Formal denitions of a graph III Denition: Mixed Graph A mixed graph G is any ve-tuple G = (V, E 1, E 2, α, ω, λ) where E 1 is a set of directed links, E 2 is a set of undirected links; sets E 1 and E 2 are disjoint (E 1 E 2 = ). Further λ, α and ω are dened as before; α and ω are dened over E 1 and λ is dened over E 2. (KA AGH) spring / 70

21 : visualisation (KA AGH) spring / 70

22 : visualisation (KA AGH) spring / 70

23 Lecture Plan 1 2 Graph as a model of the Search Space 3 Blind search strategies Breadth-First Search () Uniform-Cost Search () Depth-First Search () Deepening Search 's Algorithm of Algorithms 4 Informed search strategies 5 (KA AGH) spring / 70

24 Breadth-First Search () Breadth-rst search strategy All nodes on a given level are expanded rst. Only then deeper nodes are expanded. A B C D E F G (KA AGH) spring / 70

28 Breadth-First Search () characteristics Completeness: if the branching factor is nite and the goal node is at depth d, will eventually nd it. Optimality: is optimal if path cost is a non-decreasing function of depth. a Time complexity: 1 + b + b 2 + b b d + b(b d 1) = O(b d+1 ). Space complexity: O(b d+1 ). b a Otherwise, the shallowest node may not necessarily be optimal. b b branching factor; d depth of the goal node (KA AGH) spring / 70

29 in 8-puzzle problem (KA AGH) spring / 70

30 Uniform-Cost Search () Uniform-cost search strategy Expands the node with the lowest cost from the start node rst. a Completeness: yes, if cost of each step ɛ > 0. Optimality: same as above nodes are expanding in increasing order of cost. Time and space complexity: O(b 1+ C /ɛ ). b a If all step costs are equal, =. b C cost of optimal solution (KA AGH) spring / 70

31 Depth-First Search () Depth-rst search strategy rst expands the deepest node in the fringe. A B C D E F G H I J K L M N O (KA AGH) spring / 70

43 in 8-puzzle problem (KA AGH) spring / 70

44 Depth-First Search () characteristics Small space requirements: only the path to the current node and the siblings of each node in the path are stored. Backtracking search generates only one successor for each node. Completeness: no, if the expanded subtree has an innite depth. Optimality: no, if a solution located deeper, but located in a subtree expanded earlier, is found. Time complexity: O(b m ). Space complexity: O(bm) (linear!). (KA AGH) spring / 70

45 Depth-Limited Search (DLS) Depth-limited search strategy Modication of Depth-First Search. We introduce a maximum depth l; nodes located at depth l are treated as if they had no successors. Returns two error types: failure means no solution, cuto means no solution within given depth limit. Why DLS is not widely used? For most problems, one does not know a good depth limit until the problem is solved... (KA AGH) spring / 70

46 Depth-limited search Depth-Limited Search (DLS) = depth-first search with depth limit l, i.e., nodes at depth l have no successors Recursive implementation: function Depth-Limited-Search( problem, limit) returns soln/fail/cutoff Recursive-DLS(Make-Node(Initial-State[problem]), problem, limit) function Recursive-DLS(node, problem, limit) returns soln/fail/cutoff cutoff-occurred? false if Goal-Test(problem, State[node]) then return node else if Depth[node] = limit then return cutoff else for each successor in Expand(node, problem) do result Recursive-DLS(successor, problem, limit) if result = cutoff then cutoff-occurred? true else if result failure then return result if cutoff-occurred? then return cutoff else return failure Chapter 3 60 (KA AGH) spring / 70

47 -Deepening Search () -deepening depth-rst search strategy Deepening Search. is a strategy for determination of optimal depth limit. Just like, expands an entire layer of new nodes before going deeper. Limit = 0 A A (KA AGH) spring / 70

48 -Deepening Search () -deepening depth-rst search strategy Limit = 1 Deepening Search. is a strategy for determination of optimal depth limit. Just like, expands an entire layer of new nodes before going deeper. B A C B A C B A C B A C (KA AGH) spring / 70

49 -Deepening Search () -deepening depth-rst search strategy Limit = 2 Deepening Search. is a strategy for determination of optimal depth limit. Just like, expands an entire layer of new nodes before going deeper. B A D E F G B A D E F G C C B A D E F G B A D E F G C C B A D E F G B A D E F G C C B A D E F G B A D E F G C C (KA AGH) spring / 70

50 -Deepening Search () -deepening depth-rst search strategy Limit = 3 Deepening Search. is a strategy for determination of optimal depth limit. Just like, expands an entire layer of new nodes before going deeper. B B A D E F G H I J K L M N O A D E F G H I J K L M N O A C C B B A D E F G H I J K L M N O A D E F G H I J K L M N O A C C B B A D E F G H I J K L M N O A D E F G H I J K L M N O A C C B B A D E F G H I J K L M N O A D E F G H I J K L M N O A C C B C B C B C B C D E F G D E F G D E F G D E F G H I J K L M N O H I J K L M N O H I J K L M N O H I J K L M N O (KA AGH) spring / 70

51 -Deepening Search () characteristics Completeness: yes. Optimality: yes, if step cost = 1. Time complexity: (d + 1)b 0 + db 1 + (d 1)b b d = O(b d ). Space complexity: O(bd). Numerical comparison for b = 10, d = 5 N() = = N() = = Conclusion exhibits better performance, because it does not expand other nodes at depth d. (KA AGH) spring / 70

52 's Algorithm General description Finds the shortest path with a single source in a graph with non-negative edge weights. More information and examples (clickable links) Wikipedia PL Wikipedia EN I LO w Tarnowie (KA AGH) spring / 70

53 Bidirectional Search Ideas for bidirectional search Start the search from the initial node and the goal node in parallel. The main advantage: depth cut by 2. Problems with bidirectional search works only for -like strategies, costly test for achieving the goal, goal node must be dened explicitly (not a goal test), expand function must be reversible. (KA AGH) spring / 70

54 where: of Algorithms Criterion DLS Complete? Yes 1 Yes 2 No Yes 3 Yes Time b d+1 b 1+ C /ɛ b m b l b d Space b d+1 b 1+ C /ɛ bm bl bd Optimal? Yes 4 Yes No No Yes 5 b branching factor, d depth of shallowest solution, m maximum depth of search tree, l depth limit. 1 if b < 2 if b < and step costs ɛ > 0 3 if l d 4 if step costs are equal 5 if step costs are equal (KA AGH) spring / 70

55 Concluding Remarks For blind strategies DL is often preferred, the current path is used to avoid cycles, depth is checked to stay within the current depth limit, the cost function may be used to restrict search, forbidden states restrict the search, dynamic search-space reconguration with constraint propagation. (KA AGH) spring / 70

56 in Prolog path(f,f,t,t). path(i,f,path,t):- p(i,n), not(member(n,path)), path(n,f,[n Path],T). go(i,f,path):- path(i,f,[i],path). (KA AGH) spring / 70

57 in Prolog bf(f,[[f Path] _],[F Path]). bf(f,[path SetOfPaths],T):- extend(path,newpaths), append(setofpaths,newpaths,newsetofpaths), bf(f,newsetofpaths,t). extend([n Path],NewPaths):- bagof([nextn,n Path],(p(N,NextN), not(member(nextn,[n Path]))),NewPaths),!. extend(_,[]). go(i,f,path):- bf(f,[[i]],path). (KA AGH) spring / 70

59 Blind vs. informed search strategies Blind search methods You already know them:,, et al. They don't analyse the nodes in the fringe; they simply pick the rst one (going down or sideways). Informed search methods They try to guess which node in the fringe is most promising......by using an evaluation function, also known as the heuristic. The heuristic is based on additional knowledge about the search space. (KA AGH) spring / 70

60 algorithm family General approach: picks node for expansion based on evaluation function, f (n). We don't know goal is best; if we knew, it wouldn't be a search at all. Heuristic function h(n) is the key component of f (n). Heuristic functions h(n) = estimated cost of the cheapest path from node n to the goal node. If n is the goal node, h(n) = 0. (KA AGH) spring / 70

61 Heuristic functions Choosing an evaluation function Arad If we know the locations of cities, we know the straight-line distances between them. h SLD straight-line distance from n to Bucharest. 71 Zerind Timisoara Oradea Lugoj 70 Dobreta Mehadia 120 Sibiu Craiova Fagaras Rimnicu Vilcea 97 Pitesti Neamt Bucharest Giurgiu 87 Iasi Urziceni Vaslui Hirsova 86 Eforie Straight line distance to Bucharest Arad 366 Bucharest 0 Craiova 160 Dobreta 242 Eforie 161 Fagaras 178 Giurgiu 77 Hirsova 151 Iasi 226 Lugoj 244 Mehadia 241 Neamt 234 Oradea 380 Pitesti 98 Rimnicu Vilcea 193 Sibiu 253 Timisoara 329 Urziceni 80 Vaslui 199 Zerind 374 (KA AGH) spring / 70

62 Admissible heuristic Heuristic functions Never overestimates the cost to reach the goal, e.g. h(n) h (n) (where h (n) is the real cost to get from n to goal). Is by nature optimistic. Monotonic (consistent) heuristic For every node n and every successor n of n (generated by any action a), estimated cost of reaching the goal from n is no greater than the stop cost of getting to n plus estimated cost of reaching the goal from n : h(n) c(n, a, n ) + h(n ). This is a form of general triangle inequality: each side of a triangle cannot be longer than sum of two other sides. (KA AGH) spring / 70

63 Greedy best-rst search Only takes into account the heuristic, e.g. f (n) = h(n). Arad 366 (KA AGH) spring / 70

64 Greedy best-rst search Only takes into account the heuristic, e.g. f (n) = h(n). Arad Sibiu Timisoara Zerind (KA AGH) spring / 70

65 Greedy best-rst search Only takes into account the heuristic, e.g. f (n) = h(n). Arad Sibiu Timisoara 329 Zerind 374 Arad Fagaras Oradea Rimnicu Vilcea (KA AGH) spring / 70

66 Greedy best-rst search Only takes into account the heuristic, e.g. f (n) = h(n). Arad Sibiu Timisoara Zerind Arad Fagaras Oradea Rimnicu Vilcea Sibiu Bucharest (KA AGH) spring / 70

67 properties Completeness: No can get stuck in loops. Time complexity: O(b m ), but depends on quality of heuristic. Space complexity: O(b m ) keeps all nodes in memory. Optimality: No. (KA AGH) spring / 70

68 algorithm Idea: avoid expanding paths that are already expensive. f (n) = g(n) + h(n), where: g(n) cost so far to reach n, h(n) estimated cost from n to goal (heuristic), therefore f (n) estimated total cost of path through n to goal. Arad 366=0+366 (KA AGH) spring / 70

69 algorithm Idea: avoid expanding paths that are already expensive. f (n) = g(n) + h(n), where: g(n) cost so far to reach n, h(n) estimated cost from n to goal (heuristic), therefore f (n) estimated total cost of path through n to goal. Sibiu 393= Arad Timisoara Zerind 447= = (KA AGH) spring / 70

70 algorithm Idea: avoid expanding paths that are already expensive. f (n) = g(n) + h(n), where: g(n) cost so far to reach n, h(n) estimated cost from n to goal (heuristic), therefore Arad f (n) estimated total cost of path through n to goal. Fagaras Sibiu Oradea Rimnicu Vilcea 646= = = = Arad Timisoara Zerind 447= = (KA AGH) spring / 70

71 algorithm Idea: avoid expanding paths that are already expensive. f (n) = g(n) + h(n), where: g(n) cost so far to reach n, h(n) estimated cost from n to goal (heuristic), therefore Arad f (n) estimated total cost of path through n to goal. Fagaras Sibiu Oradea 646= = = Rimnicu Vilcea Arad Timisoara Craiova Pitesti Sibiu 526= = = Zerind 447= = (KA AGH) spring / 70

72 algorithm Idea: avoid expanding paths that are already expensive. f (n) = g(n) + h(n), where: g(n) cost so far to reach n, h(n) estimated cost from n to goal (heuristic), therefore Arad 646= Sibiu f (n) estimated total cost of path through n to goal. Fagaras Sibiu Bucharest Oradea 671= Rimnicu Vilcea Arad Timisoara Craiova Pitesti Sibiu 591= = = = = Zerind 447= = (KA AGH) spring / 70

73 algorithm Idea: avoid expanding paths that are already expensive. f (n) = g(n) + h(n), where: g(n) cost so far to reach n, h(n) estimated cost from n to goal (heuristic), therefore Arad 646= Sibiu f (n) estimated total cost of path through n to goal. Fagaras Sibiu Bucharest Oradea 671= Rimnicu Vilcea Arad Timisoara Craiova Pitesti Sibiu 591= = = = Zerind 447= = Bucharest Craiova Rimnicu Vilcea 418= = = (KA AGH) spring / 70

74 Let's suppose that... A* optimality...a suboptimal goal G 2 has been generated. Let n be an unexpanded node on a shortest path to the optimal goal G. Proof G n Start f (G 2 ) = g(g 2 ), since h(g 2 ) = 0 g(g 2 ) > g(g), since G 2 is suboptimal g(g) f (n), since h is admissible Since f (G 2 ) > f (n), A* will never select G 2 for expansion G 2 (KA AGH) spring / 70

75 A* with consistent heuristic Node expansion order If the heuristic is consistent, A* expands nodes in order of increasing f value. A* gradually adds f -contours of nodes; contour i has all nodes with f = f i, where f i < f i+1. A T Z 380 O D L M 400 S R C F P 420 G N B I U V H E (KA AGH) spring / 70

76 A* with inconsistent heuristic If h is inconsistent: As we go along the path, f may sometimes increase. A* doesn't always expand nodes in order of increasing f value, as it may nd lower-cost paths to nodes it already expanded. A* should re-expand those nodes; however, the algorithm will not re-expand them. This example is due to Prof. Dana Nau. (KA AGH) spring / 70

82 Properties of A* A* properties Completeness: Yes, unless there are innitely many nodes with f < f (G). Time complexity: Exponential, depends on mean relative error of heuristic. Space complexity: Keeps all nodes in memory. Optimality: Yes, if: for, the heuristic is admissible, for, the heuristic is admissible and consistent. (KA AGH) spring / 70

83 Heuristic function quality Heuristic functions An admissible heuristic never overestimates the cost of reaching the goal. It usually underestimates see the SLD heuristic. However, a good heuristic function tries to minimise the gap between its value and the actual cost. Example How would you design a heuristic for the 8-puzzle? Start State Goal State (KA AGH) spring / 70

84 Example Heuristic functions How would you design a heuristic for the 8-puzzle? Start State 8-puzzle: two possible heuristics Goal State h 1 (n): number of tiles not in their places h 2 (n): sum of Manhattan distances of all tiles from their places (KA AGH) spring / 70

85 Heuristic functions Example How would you design a heuristic for the 8-puzzle? Start State Goal State 8-puzzle: two possible heuristics h 1 (S) = 6 h 2 (S) = = 14 (KA AGH) spring / 70

86 Heuristic functions 8-puzzle: two possible heuristics h 1 (S) = 6 h 2 (S) = = 14 Heuristic domination If h 2 (n) h 1 (n) for all n, then h 2 dominates h 1. Therefore, h 2 is always better than h 1. Performance comparison Number of nodes expanded if solution is at depth d: d A*(h 1 ) A*(h 2 ) (KA AGH) spring / 70

87 Heuristic domination Heuristic functions If h 2 (n) h 1 (n) for all n, then h 2 dominates h 1. Therefore, h 2 is always better than h 1. Hybrid heuristics If h a and h b are admissible heuristics, then h(n) = max(h a (n), h b (n)) is admissible and dominates both h a and h b. Deriving admissible heuristics Admissible heuristics can be derived from the exact solution cost of a relaxed version of the problem. (KA AGH) spring / 70

88 Deriving admissible heuristics Heuristic functions Admissible heuristics can be derived from the exact solution cost of a relaxed version of the problem. Example: 8-puzzle For the 8-puzzle problem: If the rules are relaxed so that a tile can move anywhere, then h 1 (n) (number of misplaced tiles) gives the exact cost. If the rules are relaxed so that a tile can can move to any adjacent square (regardless of whether it's occupied), then h 2 (n) (sum of Manhattan distances) gives the exact cost Start State Goal State (KA AGH) spring / 70

89 For many problems, the solution is important, not how we got there the path is irrelevant. State space: set of complete congurations; nd optimal conguration (e.g., TSP) or conguration satisfying constraints (e.g., timetable). : keep current state, try to improve it. Example: Travelling Salesman Problem Start with any complete tour, then try to switch pairs. (KA AGH) spring / 70

90 Example: n-queensexample: n-queens Put nput queens n queens on an n on an n board n n with board no two so that queens noontwo thequeens same row, column, conictor ondiagonal same row, column or diagonal. Move a queen to reduce number of conicts. Move a queen to reduce number of conflicts h = 5 h = 2 h = 0 Almost always solves n-queens problems almost instantaneously for very large n, e.g., n = 1million (KA AGH) spring / 70

91 search ascent/descent search (or gradient ascent/descent) Also called local greedy search. Like climbing Mt. Everest in thick fog, with amnesia. Like climbing Everest in thick fog with amnesia function Hill-Climbing( problem) returns a state that is a local maximum inputs: problem, a problem local variables: current, a node neighbor, a node current Make-Node(Initial-State[problem]) loop do neighbor a highest-valued successor of current if Value[neighbor] Value[current] then return State[current] current neighbor end (KA AGH) spring / 70

92 objective function shoulder search global maximum current state algorithm can get stuck on: local maxima, ridges, ats. local maximum "flat" local maximum state space (KA AGH) spring / 70

93 search Variants of hill-climbing search If an algorithm (e.g., `standard' hill-climbing) only selects moves which improve the solution, it is bound to be incomplete. Random-start are complete, but very ineective. Stochastic hill-climbing picks one of the better successors at random. First-choice hill-climbing generates random successors until it nds one better than the current state. Random-restart hill-climbing conducts a series of searches, starting with random start states. It is complete with probability close to 1, because it must eventually generate the goal state. (KA AGH) spring / 70

94 Background Simulated annealing In metallurgy, annealing is the process used to temper or harden metals and glass by heating them to a high temperature and then gradually cool them. This allows the material to coalesce into a low-energy crystalline state. The algorithm Selects move at random. If the move improves the solution, it is made every time. If the move worsens the solution, the probability if it is made is determined upon: the amount E by which the solution is worsened, the so-called temperature T, which is decreased in every iteration. a a That way, the bad moves are more likely to be allowed at the start, and become less likely as the temperature decreases. (KA AGH) spring / 70

95 Simulated annealing Simulated annealing Idea: escape local maxima by allowing some bad moves but gradually decrease their size and frequency function Simulated-Annealing( problem, schedule) returns a solution state inputs: problem, a problem schedule, a mapping from time to temperature local variables: current, a node next, a node T, a temperature controlling prob. of downward steps current Make-Node(Initial-State[problem]) for t 1 to do T schedule[t] if T = 0 then return current next a randomly selected successor of current E Value[next] Value[current] if E > 0 then current next else current next only with probability e E/T Chapter 4, Sections (KA AGH) spring / 70

96 Local beam search Local beam search Idea: keep k states instead of 1; choose top k of all their successors. Problem Not the same as k individual searches run in parallel. Searches that nd good states invite others to join them. Threads that do not provide good results are discarded. Often, all k states end up on same local maximum. Solution: stochastic local beam search Choose k successors at random, but still be biased towards the good ones. (KA AGH) spring / 70

97 Genetic Genetic Variant of stochastic beam search. Successor states generated by combining two parent states (rather than modifying a single state). We have k randomly generated states, called the population. Each state is caled an individual. Each individual is represented as a string over a nite alphabet. Steps in GA 1 Evaluate tness of each individual in population, as probability of being selected for reproduction. 2 Perform selection, taking tness into account. 3 Perform crossover within pairs (at random point). 4 Introduce random mutation to allow for stochastic exploration. (KA AGH) spring / 70

98 Genetic Fitness 31% 29% 26% 14% Selection Pairs Cross Over Mutation + = (KA AGH) spring / 70

100 (KA AGH) spring / 70