A Re-examination of Limited Discrepancy Search

Transcription

1 A Re-examination of Limited Discrepancy Search W. Ken Jackson, Morten Irgens, and William S. Havens Intelligent Systems Lab, Centre for Systems Science Simon Fraser University Burnaby, B.C., CANADA V5A 1S6 Abstract Harvey and Ginsberg [IJCAI] have described a tree search algorithm, called limited discrepancy search (LDS), for solving constraint satisfaction problems. LDS tries to exploit the existence of good value-ordering heuristics during backtracking. This paper reformulates LDS as an iterative improvement algorithm. We compare our reformulated LDS algorithm with the original formulation and with a taboo search algorithm and find that it performs very poorly. These results apparently contradict the experimental results reported by Harvey and Ginsberg. The contradiction highlights the fact that the benefits of LDS are due not only to its exploitation of good value-ordering heuristics during backtracking but are also due to the use of LDS within a branch-and-bound loop that iteratively re-starts the search with a new cost bound. 1.0 Introduction There are often very good variable and value ordering heuristics that allow backtracking algorithms to quickly find good solutions to constraint satisfaction problems. For example, quite sophisticated heuristics have been developed for jobshop scheduling problems that alleviate the need for much backtracking. Harvey and Ginsberg [IJCAI] describe an interesting tree search algorithm called limited discrepancy search (LDS) that exploits the existence of such heuristics. The idea is that a solution constructed according to a good value-ordering heuristic will be unlikely to contain many mistakes. A discrepancy is a choice point for a variable where the chosen value differs from that specified by the heuristic. When LDS is forced to backtrack, it examines new paths in increasing order of the discrepancy count. Harvey and Ginsberg present theoretical and practical evidence that limited discrepancy search performs better than chronological backtracking. Iterative improvement algorithms (e.g. min-conflicts repair, taboo search, simulated annealing, GSAT, etc.) are an alternative to backtracking algorithms for solving CSPs. An iterative improvement algorithm starts with an initial complete solution, generates a neighbourhood of new solutions by applying some changes to the current solution, and finally picks one of the solutions from the neighbourhood as the basis for the next iteration. Iterative improvement algorithms excel at finding good (though not necessarily optimal) solutions fairly quickly. A Re-examination of Limited Discrepancy Search August 28,

2 This papers re-examines limited discrepancy search from an iterative improvement viewpoint. We use jobshop scheduling, described in section 2, as an example. Section 3 reviews the tree search formulation of LDS and makes the observation that the discrepancy count can be viewed as a measure of distance from the initial solution as used in an iterative improvement algorithm. We use this observation to formulate a new iterative improvement algorithm for LDS. Section 4 reports the results of some preliminary computational experiments that compare our reformulated LDS algorithm to a taboo search algorithm for jobshop scheduling. The performance of LDS is very poor. This is somewhat surprising given the promising results reported by Harvey and Ginsberg. In section 5, we examine the conflicting results and conclude that the original LDS algorithms works well because it is embedded in an outer loop that re-starts LDS on a newly constructed solution whenever a feasible solution is found. 2.0 The Jobshop Scheduling Problem The jobshop scheduling problem consists of a set of n jobs and m machines. Each job consists of a sequence of m activities. Each activity has a duration and requires a single machine for its entire duration. An activity must be scheduled before every activity following it in its job. Two activities cannot be scheduled a the same time if they both require the same machine. The objective is to find a schedule that minimizes the overall completion time of all the activities. The jobshop scheduling problem can be formulated as a CSP where the variables are the start times of the activities. Let S 1, S 2, S 3, be variables that denote the start times of the activities. There are two types of constraints: 1. Precedence constraints. If A 1 and A 2 are two consecutive activities within the same job then there is a precedence constraint on the start times of the activities: S 1 + duration( A 1 ) S 2 2. Disjunctive Constraints. If A 1 and A 2 are two activities that require the same resource then there is a disjunctive constraint between the start times of the activities: ( S 1 + duration( A 1 ) S 2 ) ( S 2 + duration( A 2 ) S 1 ) A solution can be constructed by choosing a start time for each activity. An alternative strategy is to choose an order (e.g. A 1 before A 2 or vice versa) for the activities in each disjunctive constraint. After choosing an order for each such pair of activities, a solution in terms of activity start times can be easily found using the critical path method. A Re-examination of Limited Discrepancy Search August 28,

3 For jobshop scheduling there are m 2 ( m 1) 2 binary ordering decisions and therefore a (complete) solution is described by a bit vector of this length. We use this ordering formulation in the rest of the paper. In particular, we view tree search algorithms as trying to choose the values for this vector one position at a time while iterative improvement algorithms make some change to this vector on each iteration. 3.0 Limited Discrepancy Search 3.1 The Tree Search Formulation of LDS In a tree search algorithm for solving the jobshop scheduling problem (using the ordering formulation), each node in the tree represents a choice about a particular ordering between two activities A 1 and A 2. Each node has two children that correspond to whether A 1 is scheduled before A 2 or vice versa. A tree search algorithm based on chronological backtracking makes a decision at each node based on some value ordering heuristic and backs up to the most recent decision when an inconsistency is detected. Constraint propagation methods can be used to help detect inconsistencies earlier in the search process. LDS tried to exploit the existence of a good value-ordering heuristic when backtracking. Consider the case when we want to choose a value of a boolean variable (e.g. an order between two activities) and the value-ordering heuristic indicates that the variable should be assigned to true. Let p be the probability that there is a feasible solution with the variable assigned to true and q be the probability that there is a feasible solution with the variable assigned to false. If the heuristic is good then we would expect that p would be greater than q. If we assume that p and q are that same for all variables regardless of their depth in the search tree then we can easily calculate the probability that a leaf node in the search tree is a feasible solution. Figure 1 on page 4 shows the search tree for a small example with three variables. Often the value ordering heuristic is less accurate at lower depths. In such cases it makes sense to change decision higher in the search tree before changing lower decisions. The order of leaf nodes examined by LDS shown in Figure 1 assumes this strategy. LDS performs a tree search with a discrepancy bound that increases on each iteration. That is, when the discrepancy bound is two then any node with discrepancy count three or greater is pruned from the tree. Hence, the algorithm is similar to iterative deepening [Korf] but uses a discrepancy bound rather than a depth bound. As with iterative deepening, the number of nodes examined in search iteration grows exponentially. Also, all nodes examined in one iteration will be examined again in the next iteration. Harvey and Ginsberg give some convincing theoretical and experimental evidence that shows that LDS out performs chronological backtracking. A Re-examination of Limited Discrepancy Search August 28,

4 probability: chronological backtracking: p 3 p 2 q p 2 q pq 2 p 2 q pq 2 pq 2 q LDS: FIGURE 1. Order for Searching Leaf Nodes with Chronological Backtracking and with Limited Discrepancy Search (LDS) 3.2 A Reformulation of LDS An alternative formulation of LDS measures the discrepancy count in terms of distance from the original solution rather than the number of nodes where the value ordering heuristic was not followed. If an initial solution is constructed by always following the valueordering heuristic then the initial solution corresponds to the left-most leaf in the search tree and it has a discrepancy count of zero. From this initial solution, we can define a neighbourhood of all the solutions that have at a discrepancy count of one. Recall that for our formulation of jobshop scheduling, a solution is a bit vector so the solutions at discrepancy one are the solutions generated by flipping one bit of the initial solution. More generally, for a discrepancy count of d, we define a neighbourhood consisting of all solutions that flip exactly d bits of the initial solution. Our reformulation of LDS iteratively searches neighbourhoods at increasing discrepancy counts. It is similar to iterative improvement algorithms in that it uses complete solutions and searches a neighbourhood at each iteration. However, unlike most iterative improvement algorithms, our LDS algorithm does not move to one of the neighbours after an iteration completes; it starts each iteration from the initial solution. Another difference it that our LDS algorithm is complete in that it will (in theory) find an optimal solution if one exists. The size of the neighbourhoods grows quickly: for a neighbourhood at discrepancy count d, there are n choose d ways of flipping d bits of the initial solution. Therefore the size of the neighbourhood grows exponentially until d reaches n 2. In practise, one may be able to reduce the size of the neighbourhoods. For jobshop scheduling, it is not worthwhile flipping a bit if that bit corresponds to an edge that is not on the critical path. Therefore, the neighbourhoods can be reduced by considering only bits that A Re-examination of Limited Discrepancy Search August 28,

5 correspond to edges on the critical path. Most of the successful iterative improvement algorithms for jobshop scheduling reduce the size of their neighbourhoods in similar ways [Vaessens]. Our reformulation of LDS also removes some redundancy from the tree search formulation. In particular, the neighbourhood at discrepancy count d does not include the solutions that were examined during the iteration at discrepancy count d 1. We do not feel that the reformulated LDS algorithm is a good iterative improvement algorithm. The best iterative improvement algorithms find a good balance between: Diversification: exploring many different solutions, and Intensification: focussing on promising parts of the search space. Our LDS algorithm does not follow up on promising parts of the search space. It will, however, eventually explore the entire search space. Therefore, we feel that our LDS algorithm will not be competitive with more balanced iterative improvement algorithms such as taboo search. Our reformulation of LDS makes it clear how to measure the discrepancy count for solutions examined by any iterative improvement algorithm. We simply count the number of bits where the current solution differs from the initial solution. We use this idea in our experiments to determine the discrepancy count for the best solution found by a taboo search algorithm. 4.0 Computational Experiments This section reports on some preliminary experiments with our reformulated LDS algorithm and a taboo search algorithm for jobshop scheduling. These results are very preliminary: we use just one instance (FT10) of the jobshop scheduling problem. The FT10 instance, first proposed by Fisher and Thompson, is a famous instance with 10 jobs and 10 machines. It was not solved optimally until The optimal solution has a cost of 930. We ran both our reformulated LDS algorithm and a taboo search algorithm on this instance starting with an initial solution with cost 1086 (17% above the optimal solution). This is a reasonable initial solution (BI-DIR, a state-of-the-art procedure by Dell Amico and Trubian [dell amico] produces an initial solution whose cost is The results are shown in Figure 2 on page 6. Both algorithms were cutoff after 10,000 iterations. It is obvious that the taboo search algorithm is performing much better. In contrast to Harvey and Ginsberg s results, our LDS algorithm does not find a solution that is within 5% of optimal: In fact, the best solution it finds has a cost of 1077 (15% above optimal). We discuss a possible reason for its poor performance in the next section. We also measured the discrepancy counts for all the nodes examined by both algorithms. The results are shown in Figure 2 on page 6 as histograms. There are only three points for A Re-examination of Limited Discrepancy Search August 28,

6 Schedule Cost LDS taboo No. Iterations FIGURE 2. Cost versus Iterations for LDS and Taboo Search o. Solutions Examined LDS taboo Discrepancy Count FIGURE 3. Discrepancy Count Histograms A Re-examination of Limited Discrepancy Search August 28,

7 LDS and they occur on the left side of the plot. The histogram illustrates that LDS is essentially spending all of its time near the initial solution. However, there are no very good solution in this area. In contrast, taboo search explores many solutions that are quite far from the initial solution. The best solution found by taboo search occurs at a discrepancy count of 88. This large discrepancy implies that an LDS algorithm is not likely to find this solution when starting from the initial solution. 5.0 Discussion and Conclusions The performance of our formulation of LDS is much worse than that reported by Harvey and Ginsberg for the original LDS algorithm. We believe that the difference in the two formulations is due to the fact that Harvey and Ginsberg use LDS within an outer branchand-bound loop: they initially solve, using LDS, a jobshop instance with a loose bound on the total schedule length. They then iteratively repeat the search but reduce the bound to the length of the last schedule found. We can view this as applying our LDS algorithm to an initial solution that is constructed in each iteration of the branch-and-bound loop. It is not clear if Harvey and Ginsberg s good results with LDS are due to LDS or are due to the re-starting of the constructive search with a new bound. We are planning more experiments to help to determine why Harvey and Ginsberg obtained good results with LDS. In conclusion, this paper has reformulated LDS in an iterative improvement framework. We used the reformulation to determine the discrepancy counts for solutions examined by a taboo search algorithm for jobshop scheduling. Some preliminary experiments have shown that our formulation of LDS performs very poorly in comparison to both taboo search and the original formulation. We attribute the poor performance to the fact that our formulation of LDS always starts from the same initial solution rather than moving to a new solution or constructing a new solution using a lower cost bound. A Re-examination of Limited Discrepancy Search August 28,