Improving CP-based Local Branching via Sliced Neighborhood Search

Transcription

1 Improving CP-based Local Branching via Sliced Neighborhood Search Fabio Parisini D.E.I.S., University of Bologna, Italy Michela Milano D.E.I.S., University of Bologna, Italy ABSTRACT In this paper we merge two problem independent search strategies, namely Local Branching and Sliced Neighborhood Search. They both integrate CP tree search with local search concepts, but while local branching is very effective in exploring small neighborhoods, its performances decrease when dealing with diversification and large neighborhood exploration. On the other hand Sliced Neighborhood Search is an effective method for exploring random slices of large neighborhoods and in moving away arbitrarily far from an incumbent solution. For this reason we obtain very good results in improving a reference solution: Local Branching obtains a 35% improvement when SNS is integrated aggressively both in the neighborhood exploration and in the diversification strategy. The tests were conducted on large instances of the Travelling Salesman Problem with Time Windows. Keywords Constraint Programming, Local Search, Local Branching, LDS, Optimization 1. INTRODUCTION A Constraint Programming model is defined on a set of variables X = [X 1,...,X n], eachwithafinitedomaind(x i) of values, and a set of constraints specifying allowed combinations of values for subsets of variables. A feasible solution X = [ X 1,..., X n] is an assignment of X satisfying the constraints. The CP solution process interleaves propagation and search: it explores the space of partial assignments using a backtrack tree search, enforcing a local consistency property using either specialised or general purpose propagation algorithms. In the following we focus on minimization problems where a cost C i,j is associated to each variable value assignment X i = j; we want to minimize C = i N Ci,X i where N = {1,...,n}. The CP solution process converges to an optimal solution (if one exists), but when the dimension of the problem Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. SAC 11 March 21-25, 2011, TaiChung, Taiwan. Copyright 2011 ACM /11/03...$ instance become large, the time to compute the optimal solution can be unaffordable. Therefore, often CP has been merged with Local Search (LS) approaches to obtain a good solution instead of an optimal one; see [15] for a recent survey. The min-conflicts algorithm [11] and the Comet language [16] are examples of the approach using modelings aspects of CP in combination with local search methods for finding solutions. Another approach employs local search to strengthen the pruning and propagation power of CP [13]. Other related approaches are search methods like large neighborhood search [14] which iteratively relaxes a part of the current solution and the re-optimises that part using for instance CP aided tree search. In this paper, we merge two search strategies that conveniently integrate the CP tree search (and constraint propagation) with local search concepts, namely Sliced Neighborhood Search [12] and Local Branching [4]. Both search strategies are general purpose strategies that do not rely on any problem dependent tuning. The motivation for merging the two is that while local branching is very effective in exploring small neighborhoods of an incumbent solution, it has poor performances either when diversification techniques are applied or when large neighborhoods have to be explored. On the other hand, Sliced Neighborhood Search can be seen as a very effective diversification mechanism, allowing to explore partially and randomly very distant portions of the search space from an incumbent solution and random portions of very large neighborhoods. We show that the resulting integration has very good performances on large instances of the Travelling Salesman Problem with Time Windows (see section 5.1 for details). 2. LOCAL BRANCHING Local branching is a successful search method proposed for 0-1 MIP [4] which is in the current implementation of IBM- Cplex 1. The idea is that, given an incumbent solution to an optimization problem, its neighborhood is searched with the hope of improving the solution quality, using tree search. After the optimal solution in the neighborhood is found, the incumbent solution is updated to this new solution and the search continues from it. The basic machinery of the framework is depicted in Figure 1. Assume we have a tree search method for solving an optimization problem P whose constrained variables are X. The k-distance neighborhood of a reference solution X 1 Note that the way in which local branching is implemented in Cplex differs from the one described in the following, see [2] for details. 887

2 Figure 1: The basic local branching framework. contains solutions within a k discrepancy value with respect to the incumbent solution X; in this setting we count a discrepancy each time a variable is assigned to a value which is different from the value the same variable takes in the incumbent solution, inheriting this concept from Limited Discrepancy Search (LDS) [7]. Definition 1. The discrepancy between X and X can be computed as follows n { (X, X) 1 if Xi = d i where d i = X i; 0 otherwise. i=1 For a given positive integer parameter k and a given incumbent solution X, the k-opt neighborhood N( X,k) is the set of feasible solutions of P satisfying the additional local branching constraint (X, X) k. This constraint defines the neighborhood of X by the space of assignments which have at most k different values; the disjunction associated with belonging or not to the neighborhood is used as a branching criterion. More precisely, the solution space associated with the current branching node is partitioned by means of the disjunction (X, X) k (X, X) k +1. In this way, the whole search space is divided into two, and thus exploring each part exhaustively would guarantee completeness. The neighborhood structure is general-purpose in the sense that it is independent of the problem being solved. The local branching framework is not specific to MIP; an integration of local branching in CP has been done in [8, 9]. A CP model is used to find a first incumbent solution X 1, then CP-based local branching proceeds similarly to the MIP one. Neighborhoods of the kind N( X i,k) are searched within discrepancy k w.r.t. the incumbent solution, by adding to the CP model the local-branching constraints (1) 888 like (X, X i) k. Such constraints can easily be encoded and propagated by reifying pairwise equivalences X j = X ij to Boolean variables B j and then posting a sum constraint on them. The CP model considered in the literature for the neighborhood exploration of an incumbent solution X i is: min j NC jxj (2) subject to AnySide cst(x) (3) (X, X i) k (4) X j D(X j) j N (5) wherec jxj isthecostofassigningvariablex j, AnySide cst(x) is any set of constraints on domain variables X. As a consequence, neighborhood exploration via CP clearly benefits from constraint propagation. The neighborhood can be explored either exhaustively or partially; neighborhood exploration for large instances has been so far implemented as a Limited Discrepancy Search guided by the incumbent solution. If the neighborhood is explored exhaustively and contains improving solutions, the best one is returned and the local branching constraint is reversed as in MIP. If the neighborhood is not explored exhaustively, the reversed local branching constraint is simply a no-good imposing [X 1,...,X n] = [ X i1,..., X in ] When the neighborhood is proved to contain no improving solution or a time limit is reached without any improving solution, a diversification step is performed to explore other parts of the search tree so as to find new feasible solutions and continue local branching thereafter. However, searching large neighborhoods in CP is not affordable and the performance of LB decrease when many diversification steps have to be done or when large neighborhoods have to be explored. In this paper, we propose to use Sliced Neighborhood Search to improve LB in its diversification step and in the large neighborhood exploration. 3. SLICED NEIGHBORHOOD SEARCH Sliced Neithborhood Search (SNS) [12] is a problem independent search strategy aimed at improving an incumbent solution X by randomly exploring slices of distant neighborhoods. As for LB, a neighborhood in SNSis definedin terms of discrepancies from a reference solution and SNS can be considered as a variant of Limited Discrepancy Search. When exploring the neighborhood of an incumbent solution X looking for a solution X, we can set an at-most k discrepancy bound by posting n k equality constraints of the kind X i = X i. Similarly, we can set an at-least k discrepancy bound by posting k difference constraints of the kind X i X i. Both bounds can be set at the same time and different values of k can be used for each bound. Therefore SNS is a search approach designed to explore a limited discrepancy neighborhood of an incumbent solution X looking for improving solutions, reaching bigger discrepancy values than the ones LDS could reach within the same time limit. The approach has an iterative structure; it explores a randomly chosen search space characterized by a given at-least and at-most discrepancy from X at each iteration. SNS relies on restarts and randomization to ensure the considered neighborhood is sufficiently well explored. It performs many randomized iterations, each iteration exploring just a slice of the limited discrepancy space w.r.t. X,

3 n Figure 2: LDS space exploration scheme n Figure 3: SNS space exploration scheme choosing each time a different set of variables and using small time limits for each iteration. Pictorially, we can imagine the incumbent solution X as a point in a two-dimensional space. The Euclidean distance between two points on the two-dimensional space corresponds to the discrepancy between two solutions. Figure 2 shows the behavior of LDS. The central point is the incumbent solution X, while the concentric circumferences enclose areas of the search space at a discrepancy from x smaller than the corresponding number. For large problems, LDS may efficiently explore only low discrepancy areas. Figure 3, instead, shows the main idea underlying SNS. The grayed out slices in the circles represent the search areas explored at each iteration of SNS; we expect SNS to be able to explore portions of the search space which are at a higher discrepancy value than those explored via LDS within the same time limit. SNS has two main parameters which need to be carefully tuned: At-least and at-most discrepancy bounds to be used in each iteration; in particular, these values could change at each iteration andthey could be related to the problem size n. Time allocated to each iteration: it could be computationally expensive to perform a complete exploration of the sampled neighborhood. We will provide further details on adequately setting these parameters in the experimental results section. 4. LOCAL BRANCHING IMPROVEMENTS VIA SNS CP-based local branching is a powerful framework for using Constraint Programming tools in a heuristic fashion. As LB and SNS have complementary strengths we argue that using SNS within the local branching framework could significantly improve its performances. Local branching is made of two major search components: the neighborhood exploration and the diversification search, as outlined in section 2. When exploring the neighborhood of the incumbent solution X we want to explore a limited discrepancy space of the kind (X, X) k in a computationally affordable way. The problem in exploring such a space is that exploring exhaustively high discrepancy values k is inefficient in CP when the size of the problem is large. Therefore one can either perform a partial neighborhood exploration, stopping at the first improving solution, or explore large neighborhoods in random slices as SNS does. 889 When performing diversification search we want to escape from theportion ofthe search space which is near, interms of discrepancy, to the incumbent solution X. That is a basic need in any metaheuristics strategy. SNS could be suitable for both these search components. Both neighborhood exploration and diversification search use an incumbent solution as a starting point, as SNS natively does. In the following sections we describe how SNS could be used in these basic local branching components; in section 5 we present experimental results that show the benefit of CP-based local branching using SNS for both the neighborhood exploration and the diversification strategy. 4.1 Neighborhood Exploration Neighborhood exploration in CP-based local branching is implemented as a Limited Discrepancy Search (LDS) guided by X; the major drawback of this approach is that LDS is not able to explore large discrepancy values within reasonable computational times. SNS is designed to explore higher discrepancy values than LDS in a incomplete way, so it is suitable for being used in such a setting where there is the need to explore high discrepancy neighborhoods without any completeness guarantee. We expect that SNS configurations having a small at-most k discrepancy bound, i.e. setting many equality constraints of the kind X i = X i, could be effectively used for local branching neighborhood exploration blocks. The value of choice for the at-most k bound should be bigger than the maximum discrepancy reachable by LDS, to ensure exploration of a wider search space, but small enough to define a search space which could still be successfully explored within a SNS iteration. 4.2 Diversification Strategy It is not obvious to find good diversification strategies for CP-based local branching. When a neighborhood search fails and some diversification is needed, it is not affordable neither to enlarge the neighborhood to explore via LDS, nor to switch to a new solution which is completely unrelated to the incumbent solution. In fact, searching for an improving solution from scratch during the diversification phase would in general require to much computational effort. SNS can be used for performing diversification search; by conveniently setting at most-k and at least-k bounds it is possible to constrain the solution X to be found to have the desired minimum and maximum discrepancy with respect to X. 5. EXPERIMENTAL RESULTS In this section, we provide some experimental results to showcase the benefits of integrating SNS within a CP-based local branching framework. Experiments are conducted using ILOG Solver 6.3 and ILOG Scheduler 6.3 on a 2Ghz Pentium IV running Linux with 1 GB RAM. 5.1 Traveling Salesman Problem with Time Windows The Travelling Salesman Problem with Time Windows (TSPTW) is the problem of finding a minimum cost path visiting a set of cities exactly once, where each city must be visited within a specific time window. TSPTW has important applications in routing and scheduling. It is therefore extensively studied in Operations Research and CP (see,

4 e.g., [3, 5]). In the following, we focus on the asymmetric TSPTW (ATSPTW) where the cost from a city i to another city j may not be the same as the cost from j to i. In TSPs, optimization usually results to be the most difficult issue: although the feasibility problem of finding a Hamiltonian tour in a graph is NP-hard, in the specific applications it is usually easy to find feasible solutions, while the optimal one is very hard to determine. On the other hand, scheduling problems with release dates and due dates usually set serious feasibility issues since they may involve disjunctive, precedence and capacity constraints at the same time. The solution of scheduling problems is probably one of the most promising Constraint Programming (CP) area of application to date. We decided to use the ATSPTW to test our search strategy as it embeds prominent optimization issues, explaining the need of a heuristic search method as local branching, together with a strong feasibility component, explaining the use of a CP-based framework. We have adopted the model of [5, 8] in which each Next i variable gives the city to be visited after city i. Each city i is associated with an activity and the variable Start i indicates the time at which the service of i begins. The model embeds an alldifferent constraint (posted on the Next variables) and a cost function C(Next). We applied the cost-based filtering described in [6] and the additive bounding described in [8]. Two different heuristics are taken into account for building a solution, the sequencing heuristics SeqHeu and the cost based heuristics CostHeu: SeqHeu builds a path starting from the initial city by assigning the Next variables; at each step it selects an activity j in the domain of Next i; in detail, the activity having the smallest reduced-cost value c ij, (obtained from the Assignment Problem relaxation) is chosen and assigned. CostHeu, instead, chooses the variable Next i having the worst potential cost reduction at each decision step. The variable is instantiated to the incumbent solution value Next i, if it is in the variable domain; to the minimum domain value otherwise. The process proceeds until all the variables are instantiated. 5.2 Experiments The experiments we conducted aimed at comparing the best CP-based local branching configuration known from the literature [9], which we will call Local Branching Configuration (LB Conf), with our CP-based local branching configurations using SNS for the diversification strategy and the neighborhood exploration. All the configurations run the same CP-based local branching code, thus finding the same initial solution for a given instance (except for the results shown in table 4); the cost of such initial solution is called Ref Value in the result tables. The quality of the results obtained from a given configuration can be evaluated in the measure in which the configuration improves over the Ref Value w.r.t. the other configurations, LB Conf in particular. It is important to note that LB Conf represents a very interesting benchmark, as it has already been experimentally proven to outperform both standard CP depth first search and LDS (see [9] for details). The tests were run on the classical ATSPTW instances proposed by [1] with a 7,200 seconds time limit on each 890 instance. The size of each instance is given by the number embedded in the instance name, representing the number of cities to be visited within the tour. The first set of experiments uses the SNS configuration from [12] as diversification strategy in the CP-based local branching, keeping all the other local branching elements the same as they are in LB Conf; we call this configuration D1 Conf in table 1. In detail, in the SNS-based diversification strategy equality constraints are set on 60% of the problem variables to ensure at-most k bound is set at 40% of the problem size and a 30 seconds time limit is set on each SNS iteration. Moreover, the SNS iterations are performed within a macro time window of 300 seconds; if no improving solution is found within the window, another time window is allocated and SNS iterates again. The heuristics used is the sequencing heuristics SeqHeu. This simple configuration already obtains good performances, better on all ATSPTW instances than the LB Conf, except for the biggest instance, We tried minor parameters variations to obtain a more stable configuration, so we developed D2 and D3. Configuration D2 reduces the time window from 300 seconds to 30 seconds, making it equal to each SNS iteration timeout. In this way we obtain a fine-grained control on the SNS iterations, allowing us to switch back to local branching from diversification as soon as a SNS iterations reports an improving solution. The 30 seconds time limit is increased when restarts occur; the optimal Luby sequence [10] is used as multiplying factor for the time limit each time a SNS iteration does not return an improving solution. In this way we expect that bigger search spaces can be explored when needed, i.e. when we are not able to find any improving solution within the given time limit, thus overcoming D1 s limitations. Configuration D3, instead, behaves exactly as D1, except for the fact that the time limit on each iteration is augmented from 30 to 50 seconds. Both D2 and D3 are designed to be more stable than D1 when dealing with biggest instances; the results, reported in table 1, show that both configurations always perform better than LB Conf, D3 obtaining many of the best results over all the configurations. Table 1: Big instances, 7,200 CPU seconds time limit, SNS used for diversification. Instance Ref value LB Conf D1 Conf D2 Conf D3 Conf Value Value Value Value rbg125a rbg rbg rbg rbg rbg172a rbg rbg rbg201a rbg The second set of experiments uses SNS as neighborhood exploration tool, substituting Limited Discrepancy Search. The first configuration we tried, N1, plugs the SNS configuration from [12] for the neighborhood exploration on the CP-based local branching code. All the other parts of the local branching code are left as they are in LB Conf, including the diversification strategy. The time limit used for neigh-

5 Table 2: Big instances, 7,200 CPU seconds time limit, SNS used for neighborhood exploration. Instance Ref value LB Conf N1 Conf N2 Conf N3 Conf Value Value Value Value rbg125a rbg rbg rbg rbg rbg172a rbg rbg rbg201a rbg borhood exploration is 180 seconds; if SNS does not find any solution within that time limit, local branching switches to the diversification step. The SNS parameters are the same used for configuration D1. From the results in table 2 we can see that this plain integration of SNS as neighborhood exploration tool provides good results when compared to the LB Conf, as it shows better results, except for a couple of instances. We then decided to run SNS with parameters tuned for performing a fast, effective exploration of areas closer to the incumbent solution X. First of all we used a different heuristics for exploring the search tree, i.e. we switched from SeqHeu to CostHeu, which is the heuristics used in LB Conf for neighoborhood exploration. To achieve proximity to X we reduced the at-most k bound from 40% to 20% by ensuring that 80% of the problem variables have their domain bound to the reference value X i. The configuration we developed is called N2, and its results are shown in table 2. The results from N2 are verygood whencompared toboth the LB Conf and N1. Its perfomance worsens on the biggest instances, where the search space defined by the at-most k bound becomes too big, as it is bound to the cardinality of the problem variables. We created a variation of N2, N3, which sets an fixed upper bound on the at-most k bound to avoid exploring search spaces which are too wide; we set this boundto 35 variables. The results from N3 confirm that this small change actually produces considerable improvements, as it allows us to get many of the best results over all the neighborhood exploration configurations. Table 3: Big instances, 7,200 CPU seconds time limit, SNS used for neighborhood exploration and diversification. Instance Ref value LB Conf SNS Conf Value % Impr Value % Impr rbg125a rbg rbg rbg rbg rbg172a rbg rbg rbg201a rbg Given the good results from using SNS separately for diversification and neighborhood exploration within the CPbased local branching, we decided to use the best SNS configurations for each of these search components in the same local branching configuration, to try and get even better results. In table 3 we compare the LB Conf with the SNS Configuration, which is a CP-based local branching configuration using N3 as neighborhood exploration tool and D3 as diversification tool. For each instance, for both configurations, a percentage improvement % Impr is computed. That value reports which ratio of the improvement interval, i.e. the absolute value of the difference between the Ref value and the best value known for the instance, has been achieved. This SNS configuration obtains results which are consistently better than LB Conf. In order to test the robustness of the SNS Configuration we decided to run further experiments using a randomized version of the heuristic used to find the initial solution. Our aim is to estimate whether SNS Conf shows a uniform behavior in closing the optimality gap, i.e. if the percentage improvement of a given instance does not drastically change when starting from a different initial solution. In table 4 we show the results of four SNS configurations, reporting three fields for each of them: the Ref value, i.e. the cost of the initial solution found, the cost of the best solution found within the 1800 seconds time limit and the percentage improvement. The difference between the four SNS configurations lies in the choice of the heuristic used for finding the initial solution; SNS Conf uses SeqHeu, while R1, R2 and R3 Conf use a randomized version of it, finding different solutions. The randomized version of SeqHeu is not always able to find an initial solution within the time limit, as it happens for instances rbg193 and rbg193.2; this is due to the fact that for such big instances it can be very hard even to find an initial solution. Nonetheless, when an initial solution is found, the SNS local branching configuration is able to cover the improvement interval in a uniform way, showing similar values in the % Impr columns of each instance. 6. CONCLUSIONS The integration of SNS within the CP-based local branching improves LB performances of 35% on average on the largest ATSPTW instances. These results show how SNS can be considered a powerful and robust tool for using CP modeling and propagation mechanisms when dealing with large optimization problems. 7. REFERENCES [1] N. Ascheuer. Hamiltonian path problems in the on-line optimization of flexible manufacturing systems. PhD thesis, Technische Universität Berlin, [2] E. Danna, E. Rothberg, and C. L. Pape. Exploring relaxation induced neighborhoods to improve mip solutions. Mathematical Programming, 102(1):71 90, [3] J. Desrosiers, Y. Dumas, M. Solomon, and F. Soumis. Time constrained routing and scheduling. In Network Routing, pages , [4] M. Fischetti and A. Lodi. Local branching. Mathematical Programming, 98:23 47, [5] F. Focacci, A. Lodi, and M. Milano. A hybrid exact algorithm for the tsptw. Informs Journal on Computing, 14(4): , 2002.

6 Table 4: Big instances, 7,200 CPU seconds time limit, testing the robustness of the SNS configuration. Instance SNS Conf R1 Conf R2 Conf R3 Conf Ref value Value % Impr Ref value Value % Impr Ref value Value % Impr Ref value Value % Impr rbg125a rbg rbg rbg rbg rbg172a rbg rbg rbg201a rbg [6] F. Focacci, A. Lodi, and M. Milano. Optimization-oriented global constraints. Constraints, 7: , [7] W. Harvey and M. Ginsberg. Limited discrepancy search. In Proc. of IJCAI-95, pages Morgan Kaufmann, [8] Z. Kiziltan, A. Lodi, M. Milano, and F. Parisini. Cp-based local branching. Proc. of CP-07, LNCS, 4741: , [9] Z. Kiziltan, A. Lodi, M. Milano, and F. Parisini. Bounding, filtering and diversification in cp-based local branching. Submitted for publication, [10] M. Luby, A. Sinclair, and D. Zuckerman. Optimal speedup of las vegas algorithms. Information Processing Letters, 47: , [11] S. Minton, M. D. Johnston, A. B. Philips, and P. Laird. Minimising conflicts: A heuristic repair method for constraint satisfaction and scheduling problems. Artificial Intelligence, 58(1): , [12] F. Parisini, M. Lombardi, and M. Milano. Discrepancy-based sliced neighborhood search. In AIMSA, pages , [13] M. Sellman and W. Harvey. Heuristic constraint propagation using local search for incomplete pruning and domain filtering of redundant constraints for the social golfer problem. In Proc. of CP-AI-OR, pages , [14] P. Shaw. Using constraint programming and local search methods to solve vehicle routing problems. Proc. of CP-98, LNCS, 1520: , [15] P. Shaw. Integration of ls and tree search. In M. Milano and P. van Hentenryck, editors, Hybrid Optimization. Springer, [16] P. van Hentenryck and L. Michel. Constraint-based Local Search. MIT Press,