Download presentation

Presentation is loading. Please wait.

Published byTori Mellish Modified over 2 years ago

1
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 1 A General Backtracking Algorithm Let us say that we can formulate a problem as a sequence of n successive decisions, with each decision consisting of a picking one choice out of a predefined set of options. For example, in the 4-queens problem we have to make four decisions, each of which consists in placing a queen in one of the four rows. We could formalize each decision as choosing one element from the set of rows [1, 2, 3, 4]. This set is the same for all four decisions. Therefore, we can describe the overall choices we have for this problem as: [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]] [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]] (placing of first, second, third, and fourth queen)

2
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 2 A General Backtracking Algorithm We build our plan for solving the problem by starting with an empty list [] and adding (prepending) our decisions as we move down the tree. For example, if we decide to place the first three queens in rows 3, 1, and 4, our current plan is [4, 1, 3]. Obviously, any solution of the problem is represented by a list of length four. We also need a “sanity check” function that tells us if a decision, given the current plan, makes sense, i.e., could potentially lead to a solution. Examples: fSanity 4 [4, 1, 3] = False fSanity 2 [4, 1] = True

3
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 3 A General Backtracking Algorithm Sanity check function for the n-queens problem: fQueens :: Int -> [Int] -> Bool fQueens a plan = fqHelper a plan 1 where fqHelper a [] dist = True where fqHelper a [] dist = True fqHelper a (p:ps) dist = fqHelper a (p:ps) dist = if elem p [a, a-dist, a+dist] then False if elem p [a, a-dist, a+dist] then False else fqHelper a ps (dist + 1) else fqHelper a ps (dist + 1)

4
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 4 A General Backtracking Algorithm Now we can write our general backtracking function: backtrack fSanity plan [] = plan backtrack fSanity plan ([]:ls) = [] backtrack fSanity plan ((a:as):ls) = if not (fSanity a plan) || null result if not (fSanity a plan) || null result then backtrack fSanity plan (as:ls) then backtrack fSanity plan (as:ls) else result else result where result = backtrack fSanity (a:plan) ls where result = backtrack fSanity (a:plan) ls nQueens n = backtrack fQueens [] (take n (repeat [1..n])) Try it out!

5
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 5 A General Graph-Searching Algorithm 1.Create search tree Tr consisting only of the start node (root) n 0. Put n 0 on an ordered list called OPEN. 2.Create empty list called CLOSED. 3.If OPEN is empty, exit with failure. 4.Move the first node on OPEN, called n, to CLOSED. 5.If n is a goal node, exit with success; the solution is the path from n to n 0 along the edges in Tr. 6.Expand node n by generating a set M of successors and connect them to n. Also put the members of M on OPEN. 7.Reorder the list OPEN according to a specific rule. 8.Go to step 3.

6
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 6 Rules for the Graph-Searching Algorithm What happens if we simply append new nodes to the end of OPEN? The algorithm turns into breadth-first search. The algorithm turns into breadth-first search. What happens if we add new nodes at the beginning of OPEN? The algorithm turns into depth-first search. The algorithm turns into depth-first search. What happens if we sort the nodes according to a heuristic evaluation function f’ ? The algorithm turns into best-first search. The algorithm turns into best-first search.

7
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 7 Best-First (Heuristic) Search We can often improve search efficiency by implementing a heuristic evaluation function f’ that estimates which node is the best one to expand in a given situation.We can often improve search efficiency by implementing a heuristic evaluation function f’ that estimates which node is the best one to expand in a given situation. Small values of f’ indicate the best nodes.Small values of f’ indicate the best nodes. In the general graph-searching algorithm, sort the nodes on the OPEN list in ascending order with regard to their f’-values.In the general graph-searching algorithm, sort the nodes on the OPEN list in ascending order with regard to their f’-values. This way, the supposedly “best” nodes are expanded first.This way, the supposedly “best” nodes are expanded first.

8
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 8 Best-First (Heuristic) Search Example: The Eight-puzzle The task is to transform the initial puzzle 283 164 75 into the goal state 1238 4 765 by shifting numbers up, down, left or right.

9
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 9 Best-First (Heuristic) Search How can we find an appropriate evaluation function? Heuristic evaluation functions have to be “custom- made” for individual problems.Heuristic evaluation functions have to be “custom- made” for individual problems. Often, it is easy to see what a reasonable (but usually not optimal) function could look like.Often, it is easy to see what a reasonable (but usually not optimal) function could look like. For the Eight-puzzle, it seems like a good idea to expand those nodes first that lead to configurations similar to the goal state.For the Eight-puzzle, it seems like a good idea to expand those nodes first that lead to configurations similar to the goal state. In our first attempt, we will simply define f’ as the number of digits in the puzzle that are not in the correct (goal) position yet.In our first attempt, we will simply define f’ as the number of digits in the puzzle that are not in the correct (goal) position yet.

10
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 10 Best-First (Heuristic) Search 283 164 75 4283164 752831 4 765283164 75 535283 14 7652 3184 76528314 765 3 to the goal 4 83214 765 3 3283714 65 48 3214 765 3 to further unnecessary expansions

11
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 11 Best-First (Heuristic) Search You see that with this simple function f’ the algorithm is still likely to perform unnecessarily many steps.You see that with this simple function f’ the algorithm is still likely to perform unnecessarily many steps. We should increase the “cost” of searches in greater depth to make the algorithm avoid them.We should increase the “cost” of searches in greater depth to make the algorithm avoid them. To achieve this, we simply add the current depth of a node to its f’-value.To achieve this, we simply add the current depth of a node to its f’-value. Now f’(n) = depth of n in the tree + number of digits in the puzzle in incorrect position.Now f’(n) = depth of n in the tree + number of digits in the puzzle in incorrect position. Let us try again!Let us try again!

12
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 12 Best-First (Heuristic) Search 283 164 75 0+4283164 752831 4 765283164 75 1+51+31+5283 14 7652 3184 76528314 765 2+3 goal ! 2+4 83214 765 3+3 2+3283714 65 3+4 23184 765 3+2123 84 765 4+11238 4 765 5+0123784 65 5+223184 765 3+4

13
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 13 Best-First (Heuristic) Search Using the improved function f’, the best-first algorithm discovers the solution much more efficiently than it did before.Using the improved function f’, the best-first algorithm discovers the solution much more efficiently than it did before. To formalize things, we now have a function f’(n) = g’(n) + h’(n), where g’(n) is a estimate of the depth (or cost) of n, and h’(n) is an estimate of the minimal distance (or cost) from n to a goal node.To formalize things, we now have a function f’(n) = g’(n) + h’(n), where g’(n) is a estimate of the depth (or cost) of n, and h’(n) is an estimate of the minimal distance (or cost) from n to a goal node. While f’(n), g’(n), and h’(n) are estimates, f(n) = g(n) + h(n) is the actual minimal cost of any path going from n 0 through n to a goal node.While f’(n), g’(n), and h’(n) are estimates, f(n) = g(n) + h(n) is the actual minimal cost of any path going from n 0 through n to a goal node.

14
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 14 Best-First (Heuristic) Search Question: What happens if for our heuristic estimation function f’(n) = g’(n) + h’(n) we simply set h’(n) = 0? Answer: Only the distance of a node from n 0 determines the cost of expanding a node. Only the distance of a node from n 0 determines the cost of expanding a node. Nodes closer to n 0 will be expanded first. Nodes closer to n 0 will be expanded first. The algorithm turns into breadth-first search. The algorithm turns into breadth-first search.

15
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 15 Best-First (Heuristic) Search And what happens if the state-space graph for our problem is not a tree? For example, is the Eight-puzzle state-space graph a tree? No. In this puzzle, actions are reversible. Any successor of a node n has n as a successor. In order to overcome this problem, we have to modify Step 6 in our general graph-searching algorithm.

16
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 16 Improved Graph-Searching Algorithm 1.Create search tree Tr consisting only of the start node (root) n 0. Put n 0 on an ordered list called OPEN. 2.Create empty list called CLOSED. 3.If OPEN is empty, exit with failure. 4.Move the first node on OPEN, called n, to CLOSED. 5.If n is a goal node, exit with success; the solution is the path from n to n 0 along the edges in Tr. 6.Expand node n by generating a set M of successors and connect them to n. Also put the members of M on OPEN. 7.Reorder the list OPEN according to a specific rule. 8.Go to step 3. 6.Expand node n by generating a set M of successors that are not already ancestors of n in Tr. Connect each node in M to node n. Also put the members of M on OPEN.

17
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 17 Algorithm A* The algorithm shown on the previous slide, using a heuristic estimation function f’(n) = g’(n) + h’(n), is also called Algorithm A*. Under the following conditions, A* is guaranteed to find the minimal cost path: Each node in the graph has a finite number of successors (or no successors). Each node in the graph has a finite number of successors (or no successors). All edges in the graph have costs greater than some positive amount . All edges in the graph have costs greater than some positive amount . For all nodes n in the search graph, h’(n) h(n), that is, h’(n) never overestimates the actual value h(n) – an optimistic estimator. For all nodes n in the search graph, h’(n) h(n), that is, h’(n) never overestimates the actual value h(n) – an optimistic estimator.

18
October 1, 2012Introduction to Artificial Intelligence Lecture 8: Search in State Spaces II 18 Algorithm A* Question: What happens if we use a “stupid” estimation function such as h’(n) = 0 ? Answer: A* is still guaranteed to find a minimal cost path. However, the more closely our function h’(n) is to the actual function h(n), the better will be the efficiency of A* in finding such a path. The effort of finding a good estimator pays off in the efficiency of the algorithm.

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google