Primal Heuristics for Branch-and-Price Algorithms

Transcription

1 Primal Heuristics for Branch-and-Price Algorithms Marco Lübbecke and Christian Puchert Abstract In this paper, we present several primal heuristics which we implemented in the branch-and-price solver GCG based on the SCIP framework. This involves new heuristics as well as heuristics from the literature that make use of the reformulation yielded by the Dantzig-Wolfe decomposition. We give short descriptions of those heuristics and briefly discuss computational results. Furthermore, we give an outlook on current and further development. 1 Introduction A wealth of practical decision and planning problems in operations research can be modeled as mixed integer programs (MIPs) with a special structure; this structure has been recently successfully exploited in branch-and-price algorithms [6] which are based on Dantzig-Wolfe decomposition [5]; we assume the reader to be familiar with both concepts. Primal heuristics are a very important aspect of MIP solving: In practice, the decision maker is often satisfied with a good solution to her problem; besides, such solutions can help accelerate the solution process. We developed and tested heuristics specially tailored for branch-and-price that exploit the fact that two different formulations of the MIP are available via the Dantzig-Wolfe decomposition: the original MIP, and the extended reformulation. We implemented our heuristics in the branch-and-price solver GCG [8] which is based on the well-known SCIP framework [1]. Whereas today s branch-and-price algorithms are almost always tailored to the application and are thus reserved to experts, the goal of the GCG project is to provide a more generally accessible solver Marco Lübbecke RWTH Aachen University, Operations Research, Templergraben 64, Aachen, Germany marco.luebbecke@rwth-aachen.de Christian Puchert RWTH Aachen University, Operations Research, Templergraben 64, Aachen, Germany puchert@or.rwth-aachen.de 1

2 2 Marco Lübbecke and Christian Puchert that is available to a much broader range of users. Our work contributes towards this goal by providing primal heuristics for branch-and-price. In the remainder, we will present three types of such heuristics called extreme point, restricted master, and column selection heuristics and discuss computational results. This work is based on the master s thesis of the second author [11]. 2 Preliminaries We want to solve MIPs of the form min c T x s. t. Ax b x X, (1) with X = {x R n : Dx d,x i Z for all i I {1,...,n}}. Typically, Ax b are some complicated or linking constraints, whereas the set X often has a block structure X = X 1 X K with X k = {x k R n k : D k x k d k,x k i Z for all i I k }, k = 1,...,K, I k {1,...n k }, K k=1 n k = n. Via Dantzig-Wolfe decomposition, (1) is reformulated to a master problem min s. t. K k=1 K k=1 p P k c p λ kp a p λ kp b p P k λ kp = 1 p P k for all k λ k R P k + for all k, (2) where integrality of the x i is enforced by constraints p Pk λ kp x kp = x k for all k and xi k Z for all i I k (convexification) or λ k Z P k + for all k (discretization). The master problem (2) bears too many variables to explicitly work with and column generation is typically applied. The pricing subproblems to generate variables as needed read as min (c k ) T x k (π k ) T A k x k π 0 s. t. x k (3) X k, one for each block k.

3 Primal Heuristics for Branch-and-Price Algorithms 3 3 Extreme Points Crossover Each component x k of the solution x yielded by solving the master problem (2) is a convex combination x k = p Pk λkp x kp, with P k being the (index) set of extreme points obtained by solving the k-th pricing problem. These are integer feasible and satisfy the constraints D k x k d k, while x k satisfies all linear constraints but is usually not integer feasible. This leads to the question: Can we exploit the integer feasibility of the x kp to obtain a solution x satisfying all constraints? This is what extreme point based heuristics try to achieve. The extreme points we are particularly interested in are those with λ kp > 0. It may happen that there is a number of coordinates in which these extreme points are identical. Especially when their values are also shared by x, it seems worth exploring whether there are more integer feasible or feasible points taking the same values. Therefore, Extreme Points Crossover performs a neighborhood search on the extreme points by crossing them: For each block, it takes those x xp with the highest λ kp, fixes the variables in which the selected points are identical and solves a sub-mip. As its name indicates, the heuristic can be compared to the Crossover heuristic discussed in [4,12] and implemented in SCIP, which considers a number of already known feasible solution for crossing. The main advantage of our heuristic against this one is that it does not need any previously found feasible solution. Fig. 1 Extreme Points Crossover: An LP feasible solution x is a convex combination of x p 1,x p 2 conv(x). All the three points have a coordinate in common which is also shared by the encircled feasible point. x p1 x x p2 Subproblem Master problem 4 Restricted Master When we solve the master problem, we dynamically add variables that improve the current solution. As the total number of master variables may be exponentially high compared to the number of original variables, this means that the master problem may soon reach a size where searching for feasible solutions would become very time-consuming. This is what the Restricted Master heuristic (suggested by Joncour et al. [9]) tries to overcome. It searches for an integer feasible master solution by restricting the formulation again to a subset of promising variables, hence regarding a problem which is of considerably smaller size than the current master formulation.

4 4 Marco Lübbecke and Christian Puchert That is, we solve a sub-mip of the master formulation (without adding any new variables to it) where all variables not contained in this subset are fixed to zero. As our subset, we chose those master variables which are part of the master LP solution, i.e., the λ p with λ p > 0. 5 Column Selection Column Selection also suggested by Joncour et al. [9] is a constructive approach to build feasible solutions from scratch, with only the knowledge of extreme points previously generated by the pricing problems. In the discretization approach, integrality is enforced by integrality constraints on the master variables. This in particular means that choosing one x kp k, p k P k, for each block k and building the Cartesian product will lead to a point x = x 1p 1 x K p K that is feasible w.r.t. the integrality and the subproblem constraints; only the master constraints may be violated. The heuristic constructs a product as above by successively choosing x kp k previously generated by the subproblems, while trying to avoid master infeasibility. Technically, this happens by increasing the corresponding master variable λ kpk in the master problem by one. There are different approaches trying to achieve that, we implemented the following two: Greedy Column Selection: Starting with λ = 0, increase a master variable such that the number of currently violated master constraints is decreased as much as possible. As a tie breaker, one can optionally use the objective coefficients of the λ kpk variables; Relaxation Based Column Selection: Starting with a rounded down master LP solution λ, we increase master variables, preferring those which actually have been rounded (i.e., the λ kpk with λ kpk > 0); this method can also be viewed as a rounding heuristic on the master variables. 6 Results We ran GCG with the above mentioned heuristics on four types of combinatorial optimization problems: bin packing, vertex coloring, capacitated p-median and resource allocation. These problems bear a bordered block-diagonal structure or at least can be brought into one which can be easily exploited by GCG. Apart from that, we also tested how several of the default SCIP heuristics [4] such as rounding heuristics, RENS, diving heuristics, and improvement heuristics perform within the branch-and-price scenario (that is, when applied to the original x variables). Previously, no primal heuristics had been implemented in GCG; only the default SCIP heuristics on the master variables were used. Now, the new heuristics as well as the SCIP heuristics on the original variable space are available to GCG.

5 Primal Heuristics for Branch-and-Price Algorithms 5 The heuristics did unfortunately not so much improve the solution time of GCG. This is actually no big surprise since it already performed well on especially the bin packing and the smaller coloring instances before the heuristics had been implemented. However, solutions could be found and the number of branch-and-bound nodes could be reduced on a large number of the problems on which the heuristics were tested; in particular, they were successful on some instances where GCG previously failed. Restricted Master Column Selection Extreme Point BIN Solutions found [% inst.] Best solution [% inst.] Running time [sec, total] Running time [sec, geom. mean] COLEASY Solutions found [% inst.] Best solution [% inst.] Running time [sec, total] Running time [sec, geom. mean] COLHARD Solutions found [% inst.] Best solution [% inst.] Running time [sec, total] Running time [sec, geom. mean] CPMP Solutions found [% inst.] Best solution [% inst.] Running time [sec, total] Running time [sec, geom. mean] RAP Solutions found [% inst.] Best solution [% inst.] Running time [sec, total] Running time [sec, geom. mean] Table 1 Results: For each heuristic and each test set, we indicate in how many percent of the instances the heuristics found a solution, how often it found the best known solution and how much time it spent over all instances in total and on average, respectively. Besides, we also had test runs on some MIPLIB2003 [2] and MIPLIB2010 [10] instances; recently, there has been made progress in detecting structures in such general MIPs even if it is not apparently visible (see [3] for details). Our results there indicate that the heuristics are also of use in that general setting; in particular, we recently succeeded with applying diving heuristics to MIPLIB2003 instances. The GCG versions of Coefficient Diving and Fractional Diving which use the master LP instead of the original LP were able to reduce the computational effort for the instances 10teams, modglob, p2756, pp08acuts, and rout. 7 Conclusion & Outlook The heuristics presented here are able to generate feasible solutions for quite a number of problem instances. Yet, there still lies some potential in them. Currently, we are improving the Extreme Points Crossover heuristic and the GCG diving heuristics. In addition, we are developing a column generation based variant of the Feasibility Pump heuristic by Fischetti et al. [7]. While the original Feasibility Pump decom-

6 6 Marco Lübbecke and Christian Puchert poses the problem into linear and integer constraints, our heuristic distinguishes like the Dantzig-Wolfe decomposition between master and subproblem constraints. That is, by alternately solving modified master problems and subproblems, we try to construct two sequences of points, hopefully converging towards each other and yielding a feasible solution. Often, like in stochastic programs or other multi-stage decision problems, a matrix has a staircase structure, i.e., we have linking variables belonging to multiple blocks. The presence of such variables is undesirable since in order to apply a Dantzig-Wolfe decomposition, one needs to copy these variables and introduce additional master constraints. A way to overcome this issue is to heuristically fix them, which is what fifty-fifty heuristics do. Another possibility is letting diving heuristics branch on those variables, hoping that they will get fixed by doing so. The results show that our heuristics have now become an important part of GCG; a number of them are now included by default. This motivates us to further pursue our research in this important area of computational integer programming. References 1. Achterberg, T.: SCIP: Solving constraint integer programs. Mathematical Programming Computation 1(1), 1 41 (2009) Achterberg, T., Koch, T., Martin, A.: MIPLIB Operations Research Letters 34(4), (2006) Bergner, M., Caprara, A., Furini, F., Lübbecke, M., Malaguti, E., Traversi, E.: Partial convexification of general MIPs by Dantzig-Wolfe reformulation. In: Günlük, O., Woeginger, G.J. (eds.), Integer Programming and Combinatorial Optimization (IPCO 2011), LNCS, 6655, pp Springer, Berlin (2011) 4. Berthold, T.: Primal Heuristics for Mixed Integer Programs. Master s thesis. Technische Universität Berlin (2006) 5. Dantzig, G.B., Wolfe, P.: Decomposition Principle for Linear Programs. Operations Research 8(1), (1960) 6. Desrosiers, J., Lübbecke, M.: A Primer in Column Generation. In: Desaulniers, G., Desrosiers, J., Solomon, M.M. (eds.), Column Generation, pp Springer, US (2005) 7. Fischetti, M., Glover, F., Lodi, A.: The feasibility pump. Mathematical Programming 104, (2005) 8. Gamrath, G., Lübbecke, M.: Experiments with a Generic Dantzig-Wolfe Decomposition for Integer Programs. In: Festa, P. (ed.), Experimental Algorithms, LNCS, 6049, pp Springer, Berlin (2010) 9. Joncour, C., Michel, S., Sadykov, R., Sverdlov, D., and Vanderbeck, F.: Column Generation based Primal Heuristics. Electronic Notes in Discrete Mathematics 3, (2010). ISCO 2010 International Symposium on Combinatorial Optimization. 10. T. Koch, T. Achterberg, E. Andersen, O. Bastert, T. Berthold, R. E. Bixby, E. Danna, G. Gamrath, A. M. Gleixner, S. Heinz, A. Lodi, H. Mittelmann, T. Ralphs, D. Salvagnin, D. E. Steffy, and K. Wolter. MIPLIB Mathematical Programming Computation, 3(2): , Puchert, C.: Primal Heuristics for Branch-and-Price Algorithms. Master s thesis. Technische Universität Darmstadt (2011) 12. Rothberg, E.: An Evolutionary Algorithm for Polishing Mixed Integer Programming Solutions. ILOG Inc. (2005)