Integer and Combinatorial Optimization: Options in Branch ...eaton.math.rpi.edu/faculty/Mitchell/courses/matp6620/notesMATP6620/lecture17/17A_bb...Kılınç-Karzan et al. [5] makes

Integer and Combinatorial Optimization:Options in Branch and Bound

John E. Mitchell

Department of Mathematical SciencesRPI, Troy, NY 12180 USA

March 2019

Mitchell Options in Branch and Bound 1 / 20

Branching variable selection

Our problem

We consider the problem

minx∈Rn cT xsubject to Ax = b

x ≥ 0xj binary, j=1,. . . ,p

where 1 ≤ p ≤ n.

We have an incumbent feasible solution xu providing an upper boundzu on the optimal value.

(It’s possible, with an abuse of notation, that xu = ∅ and zu = +∞.)



Which variable to branch on?

We have a solution xa to the LP relaxation of the current node a of thebranch and bound tree, with xa violating the integrality requirementsand with za := cT xa < zu.

We let F a0 ⊆ {1, . . . ,p} denote the variables fixed to 0 at node a and

F a1 ⊆ {1, . . . ,p} denote the variables fixed to 1 at node a.

We have decided to branch on this node.

Which variable do we branch on?



Looking just at xa

The branch and bound algorithm terminates once the upper and lowerbounds agree.

We can focus on trying to improve one of these bounds. In particular, ifwe branch on a variable with xa

j fractional but close to either 0 or 1,then we can perhaps construct a good feasible solution in just a fewnodes.

Alternatively, if we branch on a variable with xaj close to 0.5, then

perhaps the lower bound za on this node will increase most quickly.

The reasoning is that this forces the greatest change in the solution onboth branches, so it forces the solution away from xa.

In practice, it seems this rule doesn’t do much better than randomlypicking a branching variable.



Strong branching

We have a candidate set of branching variablesJ ⊆ {1, . . . ,p} \

(F a

0 ∪ F a1

).

We can test out branching on each of these variables before making adecision.



2 LPs for each possible branching variable xj

zaj0 := minx∈Rn cT x

subject to Ax = bx ≥ 0xi = 0 i ∈ F a

0xi = 1 i ∈ F a

1xj = 0

zaj1 := minx∈Rn cT x

subject to Ax = bx ≥ 0xi = 0 i ∈ F a

0xi = 1 i ∈ F a

1xj = 1



Choosing the branching variable

We then calculate the product of the improvements:

∆aj := (za

j0 − za) (zaj1 − za).

We branch on the variable j with the largest value of ∆aj .



Pseudocosts

Strong branching is expensive, requiring the solution of manyadditional LP subproblems.

An alternative is to try to estimate the values zaj0 and za

j1.

Every time we branch, we get information.

Say we branched on variable xk at node b with value zb, and solvedthe subproblems, obtaining values zb

k0 and zbk1.

We can create an estimate for the change in the objective functionvalue per unit change in the variable:

Qk0 =

zbk0−zb

xbk

Qk1 =

zbk1−zb

1−xbk

The larger these pseudocost values, the more useful it is to branch onvariable xk .



Averaging

We can get a more sophisticated estimate by averaging these valuesover all previous times we’ve branched on xk .

We can also include in the average all the times we consideredbranching on xk when doing strong branching.

A typical way to implement the branching decision in moderncommercial codes is to use strong branching in the first few levels ofthe tree and then switch to branching based on pseudocosts.

See for example Achterberg et al. [1].


Node selection

Node selection

There are several alternative available for choosing the next node.

Depth first searchIn depth first search, we immediately solve a child node after solvingits parent.

One aim is to try to quickly find a good feasible solution. One benefit isthat it should be quick to reoptimize the child node, using the solutionto the parent as a warm start.

Best boundWe choose the active node a with the smallest value of za. This nodecannot be pruned by bounds, so it will have to be solved at some point.


Node selection

Best estimate

The best estimate rule is based on the pseudocosts.

For each active node a, we calculate an estimate of the optimal valueof the best integer feasible solution for that node:

Ea = za +

p∑j=1

min{

Qj0xa

j , Qj1(1− xa

j )}

This is the value za of the node plus the estimated change in valuefrom forcing each of the binary variables to take an integer value.

The rule then selects the active node a with the smallest value of Ea.


GUB branching

GUB branching

We don’t have to branch on variable disjunctions, (xj = 0) ∨ (xj = 1).

We can branch on any inequality (πT x ≤ π0) ∨ (πT x ≥ π0 + 1), whereπ and π0 are integral, and where the current solution xa satisfies

π0 < πT xa < π0 + 1.


GUB branching

Unbalanced tree

For example, if we have a constraint∑k∈K

xk ≤ 1

for some subset K of the binary variables, a variable disjunction resultsin an unbalanced tree:

the branch with xj = 1 forces all other xk = 0,whereas the branch with xj = 0 is far less restrictive.


GUB branching

Try to get a more balanced tree

Thus, we look for a subset K1 ⊆ K with the cardinality of K1approximately half that of K , and also with∑

k∈K1

xk ≈∑

k∈K\K1

xk .

We then branch on the disjunction∑k∈K1

xk = 0 ∨∑

k∈K\K1

xk = 0.

This leads to far more balanced trees and is known as GUB(Generalized Upper Bound) branching.

SOS (Special Ordered Sets) branching is similar.


Learning branching rules

Restarting the search

Restarting the search can be used to try to improve the earlybranching decisions, exploiting preliminary computations in theconstruction of branching rules.

Recent work on restarting a B&B search for an integer programmingproblem includes Kılınç-Karzan et al. [5] and Fischetti andMonaci [3, 4].

These references all run truncated B&B searches and then use theinformation gathered in these runs to set up branching rules to make afinal complete run.



Running for a while and then restarting

Kılınç-Karzan et al. [5] makes one initial incomplete branch and boundrun until 200 nodes are fathomed.

Sparse fathomed ancestors of these nodes are found by solving mixedinteger programs.

Branch-and-bound is then restarted, with branching guided by the setof sparse ancestors:given a particular node in the tree, the process is more likely to branchon a variable that appears in many of the sparse ancestors, with thecorresponding constraints violated by the solution to the LP relaxation.

The choice of branching node is determined by CPLEX in [5].



Try out a few preliminary runs

Fischetti and Monaci [4] make five runs of B&B, with each runexploring at most five nodes.

These runs all solve the initial LP relaxation, and then branch startingfrom different optimal solutions to the relaxation.

One of these preliminary runs is then run to completion.



A backdoor

Fischetti and Monaci [3] try to identify a small set of importantbranching variables (a “backdoor”),where knowing the values of these variables would force many othervariables to take particular values.

The set of important variables is found by looking at good fractionalsolutions and ensuring that at least one of the fractional componentsappears in the backdoor.

The branch-and-bound search is then restarted with branching prioritygiven to the backdoor.



Use machine learning

There has also been recent work on using machine learningtechniques to determine branching rules, for example to derive abranching rule that can replicate strong branching at lowercomputational cost by Alvarez et al. [2].

Machine learning and related approaches to branching are surveyedby Lodi and Zarpellon [6].



References

T. Achterberg, T. Koch, and A. Martin.Branching rules revisited.Operations Research Letters, 33(1):42–54, 2005.

A. M. Alvarez, Q. Louveaux, and L. Wehenkel.A machine learning-based approximation of strong branching.INFORMS Journal on Computing, 29(1):185–195, 2017.

M. Fischetti and M. Monaci.Backdoor branching.INFORMS Journal on Computing, 25(4):693–700, 2013.

M. Fischetti and M. Monaci.Exploiting erraticism in search.Operations Research, 62(1):114–122, 2014.

F. Kılınç-Karzan, G. L. Nemhauser, and M. W. P. Savelsbergh.Information-based branching schemes for binary linear mixed integer problems.Mathematical Programming Computation, 1(4):249–293, 2009.

A. Lodi and G. Zarpellon.On learning and branching: a survey.TOP, 25(2):207–236, 2017.



References









References









References









References









References








Documents

Integer and Combinatorial Optimization: Options in Branch ...eaton.math.rpi.edu/faculty/Mitchell/courses/matp6620/notesMATP6620/lecture17/17A_bb...Kılınç-Karzan et al. [5] makes