Augmenting COIN/Sbb with a Variety of Node Selection Strategies

1
Augmenting COIN/Sbb with a Variety of Node
Selection Strategies
Gabrielle Grun Initially, as a part of my Ph.D.
research, I attempted to implement the gamut of
node selection strategies in the commercial CPLEX
(it is too inflexible and the critical parts of
the code are inaccessible), the open source
SYMPHONY (it is not as current and as widely used
as COIN) and COIN/BCP. Prior to working with
COIN, I had no experience with C. The
documentation for using and compiling BCP was
inaccurate and out-of-date. It was very
frustrating just getting the unaltered BCP code
to compile in the CSSNet environment. In
addition, BCP is merely a framework, not an
actual branch and bound code. I joined the
coin-announce, coin-discuss, etc. mail-lists on
November 15th, 2002.   When I came across the
announcement of the launching of a branch and
bound code which is less complicated than BCP,
namely Sbb, on January 7th, 2003, I was quite
excited. The coding contest was mentioned in
the same coin-announce digest, and when I found
out that the modifications that I intended to
make to Sbb qualified as a contest submission, I
decided to work towards entering the contest.
Even with Sbb, there was a paucity of
documentation, and there were incompatibilities
with the computing environment at SFU. However, I
received some assistance with the technical
difficulties from the COIN-OR community---John
Forrest and (Laszlo Ladanyi. I

• Gabrielle Assunta Grün
• Simon Fraser University
• grun_at_cs.sfu.ca

2
Introduction to IP (1)

• The goal of the integer linear programming is
• to optimize, i.e. either maximize or minimize a
  linear objective function subject to a set of
  linear constraints, where any subset of
  variables is restricted to be integer.
• In addition, the optimal variable assignment must
  meet the range restriction of variables.

3
Introduction to IP (2)

• Formally, an integer linear programming (ILP)
  problem is of the form
• Maximize cx
• Subject to Ax1Ax2b
• lXU
• We will assume that we are dealing with
  maximization problems minimization is similar.

4
Introduction to IP (3)

• The optimal value of the objective function is
  represented by z.
• We will now outline the IP branch and bound
  algorithm

5
Introduction to IP (4)
6
Introduction to IP (5)

• Step 3(b) can be completed by modern simplex
  codes (the popular choice) or interior point
  methods.
• In our work, the emphasis is on Step 3(a).
• The algorithm we have shown is very primitive.
• no probing, preprocessing, cutting planes, etc.
• justification

7
Node Selection Strategies (1)
Gabrielle Grun   DFS and breadth use the depth
method/field of the SbbNode class to access the
depth of a node. BFS uses the objectiveValue
method/field to defined in SbbNode.hpp to assess
the objective function value of a mode.  
Hereafter, each technique will be followed by an
ordered pair representing the name of the class
in SbbCompareActual.hpp for all strategies
already included in Sbb (excluding user) and
SbbCimpareUser.hpp for all user-defined
strategies and its value in enum
comparisonStrategies_t.  

• Note an signifies that the node selection
  technique was already present in the unaltered
  Sbb (simple branch and bound) developed by John
  Forrest.
• Each strategy is implemented as a class with a
  function test that returns true if given two
  nodes, x and y, y is preferable and false
  otherwise.
• Static techniques
• DFS (implemented as the SbbCompareDepth class
  in SbbCompareActual.hpp)select as dfs in enum
  comparisonStrategies_t defined in SbbEnum.hpp
  advantageous as int feasible solutions are
  usually found deeper in the search tree

8
Node Selection Strategies (2)
Gabrielle Grun    

• BFS (SbbCompareObjective, bfs) minimizes
  superfluous nodes
• Random choice (SbbCmpareRandom, randomChoice)
  to compare with more intelligent choices
• Breadth (SbbCmpareBreadth, breadth)

9
Node Selection Strategies (3)
Gabrielle Grun     An extra field was added to
the SbbNode classestimates, a map of enum
estimates_t (an enumeration type representing all
estimate strategies, although the map is only
utilized for rnumUnsatisfiedMod,
sumUnsatisfiedMod, sumUnsatisfied, AVVInfPart,
AVVIntPart and the pseudocost estimates) to
double. The values for estimates are assigned in
the choseBranch method of SbbNode.cpp (where
numberUnsatisfied is also assigned a value). The
values for numUnsatisfiedMod, sumUnsatisfiedMod,
ssumUnsatisfied, AVVInfPart, and AVVIntPart are
computed with the help of the getDistanceAndAllow
ableVariableValues method (adapted from the
unfeasibility method) for both SbbClique and
SbbSimpleInteger in SbbBranchActual.cpp. At the
time of the contest, there was only one choice
for the sum of integer infeasibilities. In its
functioning, it was like the current
sumUmsatisfiedMod but it was referred to as
sumUnsatisfied. Note that while the
numberUnsatisfied field originally existed in the
SbbNode class, it did not form the basis of its
own node selection strategy.    

• Non-objective function value estimates---metrics
  intended to lead to good int sols
• Number of integer infeasibilities
• (SbbCmpareOriNumUnsatisfied, oriNumUnsatisfied)
• (SbbCmpareNumUnsatisfiedMod, numUnsatisfiedMod)
  differs from oriNumUnsatisfied in the computation
  for cliques (for simple integers, the computation
  is the same) each member variable of a clique
  is considered individually
• Sum of integer infeasibilities
• (SbbCmpareSumUnsatisfied, sumUnsatisfied)
• sumUnsatisfiedMod is similar to numUnsatisfiedMod

10
Node Selection Strategies (4)

• The ratio of the sum of integer infeasibilities
  to the number of integer infeasibilities
  (SbbCompareRatioSumToNumUnsatisfiedMod,
  ratioSumToNumUnsatisfiedMod)
• The weighted addition of the sum of integer
  infeasibilities to the number of integer
  infeasibilities (SbbCompareWeightedSumToNumUnsatis
  fiedMod, weightedSumToNumUnsatisfiedMod)
• Minimum allowable variable values
  (SbbCompareAllowableVariableValues, AVVInfPart or
  AVVIntPart)

11
Node Selection Strategies (5)
Gabrielle Grun The heuristic estimate uses the
guessedObjectiveValue field in the SbbNode class
which is assigned in SbbModel.cpp making use of
the SbbHeuristic class. The computation of the
projection estimates in the computeValue method
of the SbbObjEstimate class of the
SbbCompareUser.hpp file utilizes the objective
function value and the sum (or number) of
integer infeasibilities of the node and the root
node as well as the best int solution so far
(the method takes two arguments, a pointier to a
SbbNode and a pointer to a SbbModel).

• Direct objective function value estimates---the
  best objective function value from a node and its
  descendants given integrality
•  Heuristic estimate (SbbCompareEstimate,
  heuristicEstimate)
• Best projection (SbbCompareProE, ProE)
• Best projection using the number of integer
  infeasibilities instead of the sum
  (SbbCompareProNumE, ProNumE)

12
Node Selection Strategies (6)
Gabrielle Grun The pseudocost estimates were not
fully implemented at the time of the contest. The
computation of the standard pseudocost estimate
in SbbNode.cpp is aided bib the computeDownPseudo
and computeUpPseudo methods (the calculation of
the midfield pseudocost estimates is supported by
the setDownPseudo, setUpPseudo and setRandPseudo
method) in SbbBranchActual.cpp for both cliques
and simple integers. Note that for cliques, there
was a choice to treat the member variables as a
group or indistinctly. Since all the integer
variables are already regarded as a group wig\th
the altered pseudocost estimates, the variables
in a clique are dealt with separately for the
standard psuidupckost estimate.

• Pseudocost estimates
• Standard pseudocost estimate (SbbComparePseudoE,
  PseudoE)
• Altered pseudocost estimate taking the average
  (minimum or maximum) of objective value
  differences caused by rounding of integer
  variables as a group (SbbCompareDiffPseudoAver(Min
  or Max)E, DiffPseudoAver(Min or Max)E )

13
Node Selection Strategies (7)
Gabrielle Grun   A norm estimate makes use of a
direct objective function value estimate, so the
type of this estimate has to be specified.   The
following files alone have been modified or
added to COIN/Sbb SbbEnum.hpp, StringConv.h,
SbbBranchActual.cpp, SbbBranchActual.hpp,
SbbBranchBase.cpp, SbbBranchBase.hpp,
SbbModel.cpp, SbbModel.hpp, SbbNode.cpp,
SbbNode.hpp, (SbbMessage.hpp after the contest
submission) sample2.cpp, runtimes, and Makefile
(Makefile.sample2). The following fields were
added to the SbbModel class number of
infeasibilities at continuous modified for
cliques int continuousInfeasibilitiesMod_, the
type of objective based estimate for a norm
estimate enum objEstimate_t
objEstimateForNorm_, sum of infeasibilities at
continuous double ontinuousSumInfeasibilities,
modified sum of infeasibilities at continuous
(after the contest) double ontinuousSumInfeasib
ilitiesMod, number of integer nodes int
umberIntegerNodes_, number of times upper bound
(best int sol) changed int timesUpperBoundChanged
_, optimality gap (after the contest) double opt
Gap_.

• Indirect objective function value estimates
• Norm estimate (SbbCompareNormE, NormE)
• Second norm estimate (SbbCompareNorm2E, Norm2E)
• Third norm estimate (SbbCompareNorm3E, Norm3E)
• Alternate norm estimate (SbbCompareAltNormE,
  AltNormE)
• Second alternate norm estimate (SbbCompareAltNorm2
  E, AltNorm2E)
• Third alternate norm estimate
  (SbbCompareAltNorm3E, AltNorm3E)

14
Node Selection Strategies (8)

• Multi-phase strategies---find good int sols in
  the first phase, and in the next phases, prove
  that no better solutions exist
• Default (SbbCompareDefault, defaultWay) before
  first integer solution, SbbCompareDepth is used,
  afterward a modified ProNumE with 98 of the cost
  of integrality (not 100)
• User (SbbCompareUser, user) before first int
  sol or rounded sol, choose by numberUnsatisfied
  ((if equal, decide by depth), after 1 to 5 int
  sols, modified ProNumE as above, more than 5 int
  sols, BFS
• User using sum of integer infeasibilities instead
  of the infeasibility count (SbbCompareUserSumUnsa
  tisfied, sumUnsatisfied)

15
Future Work (1)
Gabrielle Grun Diving occurs when one of the two
children resulting from branching is selected
rather than adding the children to the active
list and selecting a mode from the candidate
list. Advantages into feasible solutions are
usually deeper in tree and minimal context
switching,

• Enhancing Sbb with a full spectrum of diving
  technique
• compare the performance of the different diving
  strategies to determine which approach is best
  under what conditions
• Applying machine learning to chose the right node
  selection method
• Within a problem instance
• Saatys Theory of Hierarchies and Eigenvectors
  analysis for decision-making using raw
  performance data as preferences

16
Future Work (2)

• Within a problem class
• What are the problem classes and feature sets?
• First approximation, use classification packages
  like SVM, SNoW, TextBooster, C5.0
• Clustering with a package like CLUTO
• Follow Target Analysis template