Search and Optimization

Transcription

1 Search and Optimization

2 Search, Optimization and Game-Playing The goal is to find one or more optimal or sub-optimal solutions in a given search space. We can either be interested in finding any one solution or interested in finding the best solution determined by some measure. Some examples of search and optimization problems. Laying out VLSI circuits. Planning the motion of robotic arms. Airline crew scheduling. Game playing. Theorem proving.

3 Techniques Divide-and-Conquer. Backtracking. Branch and Bound. Alpha-Beta Pruning.

4 Search Trees The search space is the set of all possible solutions and non-solutions that are valid configurations for the given problem. The search space is represented by a search tree with the following characteristics. Each node represents a problem or sub-problem. The root of the tree represents the original problem. Child nodes are created by adding constraints to the problem.we can have two kinds of nodes: AND-node: All child nodes must be solved to solve the problem at this node. OR-node: Any child node can be solved to solve the problem at this node.

5 Types of Search Trees AND-tree: All nodes are AND-nodes. Use Divide-and-Conquer to solve. OR-tree. All nodes are OR-nodes. Use Backtracking with Branch and Bound to solve. AND/OR-tree. Min-Max trees are examples that are used for game playing. Use Alpha-Beta Pruning.

6 Backtrack Search Uses recursive depth-first search to explore the search space. Depth-first search keeps going down a path as long as it can. If it reaches a node with no children ( dead end ), then it back tracks to its parent and tries another child node that it hasn t already explored. If it has explored all child nodes, then it backtracks up one more level and continues. If the average branching factor is b and the depth of the search tree is k, then backtrack search requires O(b k ) time, which is exponential. Classic examples of problems requiring backtrack search.

7 Backtrack Search Uses recursive depth-first search to explore the search space. Depth-first search keeps going down a path as long as it can. If it reaches a node with no children ( dead end ), then it back tracks to its parent and tries another child node that it hasn t already explored. If it has explored all child nodes, then it backtracks up one more level and continues. If the average branching factor is b and the depth of the search tree is k, then backtrack search requires O(b k ) time, which is exponential. Classic examples of problems requiring backtrack search. -queens problem. How to place queens on a chessboard such that none of the queens can take another queen? Generalize to n-queens problem. Knight s Tour. Is there a sequence of moves for a knight on a chess board such that it covers the whole board and lands on each square once and only once during its tour? Again generalize to n n board. Creating a crossword puzzle.

8 Sequential N-Queens (Java version) public boolean placequeens(int n) { if (n > size) return false; if (n == 0) return true; } int i = 0; int j = 0; while (true) { if (checkpos(i,j)) { board[i][j] = true; if (placequeens(n-)) return true; else board[i][j] = false; } j++; if (j == size) { j = 0; i++; if (i == size) return false; } }

9 Faster Sequential N-Queens (Java version) public boolean fasterplacequeens(int n) { if (n > size) return false; if (n == 0) return true; for (int i=0; i < size; i++) if (checkpos(size-n,i)) { board[size-n][i]=true; if (fasterplacequeens(n-)) return true; else board[size-n][i]=false; } return false; }

10 Parallel Backtrack Search: Algorithm I Each process works on one subtree. Assume that the number of processes is p = b r. Each process searches the tree until depth r using the sequential algorithm. Then each process picks one subtree to work on. If the depth of the search tree is greater than r, then the time for the first step is inconsequential. Search trees are unbalanced. We can get better load balancing by letting each process explore until some depth m such that b m >> p. Then each process picks up its share of subtrees (from different parts of the search tree). The trade-off is that increasing m results in computations being performed that the sequential algorithm would have avoided.

11 Parallel Backtrack Search: Algorithm II In the previous algorithm we used depth-first search to the point where we had p subtrees. But that could lead to load balancing problems. In this algorithm we will run the depth-first search longer, generating several subtrees per process.

12 Branch and Bound Branch and bound is a variant of backtracking search that takes advantage of information about the optimality of partial solutions to avoid considering solutions that cannot be optimal. So we are still doing an exhaustive search but potentially avoiding exploring large parts of the search space that are not going to give us a solution. Given an initial problem and some objective function f to be minimized, the branch and bound technique works as follows.

13 Branch and Bound Branch and bound is a variant of backtracking search that takes advantage of information about the optimality of partial solutions to avoid considering solutions that cannot be optimal. So we are still doing an exhaustive search but potentially avoiding exploring large parts of the search space that are not going to give us a solution. Given an initial problem and some objective function f to be minimized, the branch and bound technique works as follows. If the problem is small enough, then solve it directly. Otherwise the problem is decomposed into two or more subproblems. Each subproblem is characterized by the inclusion of one or more constraints. For each subproblem, we compute a lower bounding function g. This lower bound represents the smallest possible cost of a solution to the subproblem, given the constraints on the given subproblem.

14 Branch and Bound Branch and bound is a variant of backtracking search that takes advantage of information about the optimality of partial solutions to avoid considering solutions that cannot be optimal. So we are still doing an exhaustive search but potentially avoiding exploring large parts of the search space that are not going to give us a solution. Given an initial problem and some objective function f to be minimized, the branch and bound technique works as follows. If the problem is small enough, then solve it directly. Otherwise the problem is decomposed into two or more subproblems. Each subproblem is characterized by the inclusion of one or more constraints. For each subproblem, we compute a lower bounding function g. This lower bound represents the smallest possible cost of a solution to the subproblem, given the constraints on the given subproblem. On any path from the root to a leaf node, the lower bounds are always nondecreasing. The issues are: How are the problems generated? How is a particular subproblem selected as the point to continue the search? How are hopeless subproblems discarded? How does the algorithm terminate?

15 Branch and Bound Example: -puzzle -puzzle. Move the tiles such that the tiles are in row major ordering. The goal is to minimize the number of moves to get at the solution. State space tree: The tree of possible board positions. Lower bounding function: The total of the number of moves made so far and the sum of Manhattan distance between each out of place tile and its correct location.

16 Branch and Bound Example: -puzzle -puzzle. Move the tiles such that the tiles are in row major ordering. The goal is to minimize the number of moves to get at the solution. State space tree: The tree of possible board positions. Lower bounding function: The total of the number of moves made so far and the sum of Manhattan distance between each out of place tile and its correct location. The search proceeds from the node having the smallest value. If two or more nodes have the same value, then the search proceeds from the node farthest from the root. (Why?)

17 State Space Tree for -puzzle

18 Branch and Bound Solution for the -puzzle

19 Parallel Branch and Bound Use a distributed priority queue of unexamined problems one queue per process. Each iteration, a process removes the unexamined subproblem with lowest bound from the priority queue and either solves it directly or divides it into subproblems. It sends one unexamined subproblem to another process and receives (on average) one unexamined subproblem from another process.

20 Parallel Branch and Bound Use a distributed priority queue of unexamined problems one queue per process. Each iteration, a process removes the unexamined subproblem with lowest bound from the priority queue and either solves it directly or divides it into subproblems. It sends one unexamined subproblem to another process and receives (on average) one unexamined subproblem from another process. The performance depends upon the heuristic used by the processes to exchange unexamined subproblems in order to load balance. Here are some common heuristics. Keep newly created subproblem with the lower bound and send the problem with the higher bound. (average to poor performance) Put both newly created subproblems into local queue, delete the second best problem from the local queue and send it. (best performance) Put both newly created subproblems into local queue, delete the best problem from the local queue and send it. (second best performance)

21 Parallel Branch and Bound Use a distributed priority queue of unexamined problems one queue per process. Each iteration, a process removes the unexamined subproblem with lowest bound from the priority queue and either solves it directly or divides it into subproblems. It sends one unexamined subproblem to another process and receives (on average) one unexamined subproblem from another process. The performance depends upon the heuristic used by the processes to exchange unexamined subproblems in order to load balance. Here are some common heuristics. Keep newly created subproblem with the lower bound and send the problem with the higher bound. (average to poor performance) Put both newly created subproblems into local queue, delete the second best problem from the local queue and send it. (best performance) Put both newly created subproblems into local queue, delete the best problem from the local queue and send it. (second best performance) Conditions for an optimal solution. At least one of the solution nodes must be examined. Processes must examine all nodes in the state space tree that have lower bounds less than the candidate solution.

22 Anomalies in Parallel Branch and Bound Increasing the number of processors could lead to a slow down. = = = = = B A = = > n > = = = = = =... k levels > > > Superlinear speedup, though rare, is also possible. n

23 Game Trees A two player game tree represents possible outcomes in a two person game. The leaf nodes represent outcomes of the game, interior nodes represent intermediate conditions. The scores are in terms of the first player: positive means first player wins, negative means the second player is winning. The root represents the first player, the second level the second player, the third level the first player and so on. The minmax algorithm assumes that the second player tries to minimize the gain of the first player, while the first player tries to maximize her or his gain. The chess game tree has about possible nodes, which are far too many for to evaluate completely.

24 Game Tree max st player nd player min max 9 min 9 A Game Tree

25 Alpha-Beta Pruning The deeper the search in the game tree, the better the quality of play. Alpha-beta pruning avoids searching subtrees whose evaluation cannot influence the outcome of the search, that is, cannot change the choice of a move. Hence it allows a deeper search in the same amount of time. When the search reaches a node, some choice of moves has already been considered that leads to a value of at least α for the first player. We also know that correct play on the part of the second player cannot get a value more than β. Thus [α..β] defines a window for the search. Then we have three cases: If the node pos is a max-node, then it is the first player s move. If val, the value of the game tree searched from node pos is greater than α, then α is changed to val, a better line of play has been found for player one. If the node pos is a min-node, then it is the second player s move. If val, the value of the game tree searched from node pos is less than β, then β is changed to val, a better line of play has been found for player two. If the value of α exceeds β, there is no need to search further. It is in the best interests of one of the players to block the line of play leading to node pos.

26 Alpha-Beta Pruning st player nd player max min max min 9 9 Alpha Beta Pruning

27 Sequential Alpha-Beta Pruning Alpha-Beta(pos, α, β, depth) // α lower cutoff value, by reference // β upper cutoff value, by reference // pos position // depth search depth // maxc maximum possible number of moves // Local // c[... maxc] children of pos in game tree // i iterates through legal moves // val value returned from search // width number of legal moves. if depth 0. then return Evaluate(pos). width Generate.moves(pos). if width = 0. then return Evaluate(pos). cutoff false. i 0. while i width and cutoff = false 9. do val Alpha-Beta(c[i], α, β, depth ) 0. if pos is max-node and val > α. then α val. else if pos is min-node and val < β. then β val. if α < β. then cutoff true. i i +. if pos is max-node. then return α 9. else return β

28 Perfectly Ordered Game Tree Perfectly Ordered Game Tree Root is a Type node. The left child of a Type node is a Type node. Other children are of Type. The left child of a type node is a Type node. All other children can be pruned. All children of a Type nodes are of Type.

29 Improvements on Alpha-Beta Search The alpha-beta pruning algorithm does the most pruning on the perfectly-ordered game tree, that is, a game tree in which the best move from each position is always searched first. Assuming a perfectly-ordered game tree with a depth of d and branching factor of b, the number of leaf nodes examined is: b d/ + b d/ Improvements on the basic alpha-beta pruning. Aspiration search: guess an initial window (v e, v + e) to narrow the search. Iterative Deepening: use of a (d ) level search to prepare for a d level search. Allows the time spent in a search to be controlled. Results of the (d )-ply search can be used to improve the ordering of the d-ply search, making the node ordering be more similar to perfectly-ordered. Also, the value returned by the (d )-ply search can be used as the center of the window for the d-ply aspiration search.

30 Parallel Alpha-Beta Pruning Parallel Aspirational Search. Divide into ranges and search in parallel. This is a generalization of aspiration search, Speedup is limited to or. Parallel Subtree Evaluation. Minimizing communication overhead. Split the game tree at the root and give every processor an equal share of the subtrees. Let each processor perform an independent alpha-beta search with the window [, + ]. Leads to poor speedup because the game tree is imbalanced. Minimizing search overhead. The parallel algorithm prunes the same nodes as the sequential algorithm. This is achieved by delaying the search in some subtrees until more accurate bounds information is available.

31 Distributed Tree Search Suitable for solving a variety of tree-search problems. Assigns processes to the nodes of the search tree. Each process controls one or more processors. The assignment is dynamic and we keep track of parent-child relationships. When a process is assigned to a nonterminal node, it generates the children of that node by evaluating the legal moves. Then the process assigns processors to children node based on the allocation strategy. For example, in breadth-first scheme, one processor is allocated to each child node until there are not more processors. Then a new process is created for each child node that is allocated at least one processor. The parent process suspends until it receives a message from another process. When a process is assigned to a terminal node, it returns the value of that node and its set of allocated processors to the parent and then terminates.

32 Distributed Tree Search (continued) The first child to complete the search of its subtree sends a message with the values of α and β to its parent. When it terminates, it returns its set of processors to the parent. The parent wakes up on receiving a message. It reallocates the freed processors to one or more of its active child processes. It also sends one or more of its child processes the new values of α and β. Branch and Bound processor allocation. When the search reaches a node of type node, all processors are allocated to the leftmost child. After the search returns with cutoff bounds from the subtree rooted by the leftmost child, the processors are assigned to the remaining children in a breadth-first manner. When the search reaches a type or node, cutoff bounds already exist, and the processors are assigned in a breadth-first manner