Pests of mustard_Identification_Management_Dr.UPR.pdf
Exploiting variable associations to configure efficient local search in large-scale set partitioning problems
1. Exploiting Variable Associations
to Configure Efficient Local Search
in Large-Scale Set Partitioning Problems
Shunji Umetani
Graduate School of Information Science and Technology,
Osaka University
February 19, 2015
3. Set partitioning problem (SPP)
• Given a ground set of elements i ∈ M = {1, . . . , m}, and n
subsets Sj ⊆ M (j ∈ N = {1, . . . , n}) with costs cj > 0.
• Find a minimum cost partition X ⊆ N satisfying
∪
j∈X Sj = M
and Sj ∩ Sk = ∅ ∀j, k (j ̸= k).
• SPP has many applications such as crew scheduling, vehicle
routing, facility location and logical analysis of data.
1
2 3
4
1
2 3
4
1
2 3
4
S1
S2
c1=3
S3S4
S5
c2=1
c3=1
c5=4
c4=1
optimal solution for SPP
cost = 4
optimal solution for SCP
cost = 3
4. 0-1 integer program (0-1IP) formulation
• We consider a class of 0-1 integer program (0-1IP) including
set packing, covering and partitioning problems, that is, 0-1IP
with 0-1 constraint matrix (aij ∈ {0, 1}).
• The i-th row illustrates an element i ∈ M and the j-th column
illustrates a subset Sj (j ∈ N).
min z(x) =
∑
j∈N
cj xj
s.t.
∑
j∈N
aij xj ≤ bi , i ∈ ML,
∑
j∈N
aij xj ≥ bi , i ∈ MG ,
∑
j∈N
aij xj = bi , i ∈ ME ,
xj ∈ {0, 1}, j ∈ N.
aij =
{
1 i ∈ Sj
0 i ̸∈ Sj
xj =
{
1 j ∈ X
0 j ̸∈ X
5. Outline of our algorithm
• Our algorithm consists three main components:
1 Fast incremental evaluation of neighbor solutions
2 Finding promising neighbor solutions in the large neighborhood
3 Adaptive control of penalty weights (skip in this presentation)
1-flip nb. search
Update penalty weight
Start
Exit
2-flip nb. search
(3,4)-flip nb. search
Local Search
6. Search space and evaluation
• The problem only to find a feasible solution is NP-complete.
• Allow excess y+
i and shortage y−
i of the i-th constraint and
introduce a penalty function with penalty weights w+
i , w−
i .
min z(x) =
∑
j∈N
cj xj +
∑
i∈ML∪MG ∪ME
(w+
i y+
i + w−
i y−
i )
s.t.
∑
j∈N
aij xj − y+
i ≤ bi , i ∈ ML,
∑
j∈N
aij xj + y−
i ≥ bi , i ∈ MG ,
∑
j∈N
aij xj − y+
i + y−
i = bi , i ∈ ME ,
xj ∈ {0, 1}, j ∈ N,
y+
i , y−
i ≥ 0, i ∈ ML ∪ MG ∪ ME .
7. Local search (LS) algorithm
• Start from an initial solution x, and repeats replacing x with a
better solution in its neighborhood NB(x) until no better
solution is found in NB(x).
• Searching the larger neighborhood increases chance to find
improving solutions but very time consuming.
local optimal solutionlocal optimal solution
Initial solution
Construct an initial solutionConstruct an initial solution
Construct neighborhood
Replace the current solution
Is there an
improved solution?
Local optimal solutionLocal optimal solution
No
Yes
8. Neighborhood structure
• The k-flip neighborhood NBk(x) for 0-1IP is defined by
NBk(x) = {x′ ∈ {0, 1}n | d(x, x′) ≤ k}.†
• The 4-flip operation naturally achieves exchange of two
assignments when 0-1IP partially has assignment structure.
• Search 1-flip neighborhood, 2-flip neighborhood and (3,4)-flip
neighborhood in this order.
x11
x12
x21
x22
x11
x12
x21
x22
†
d(x, x′
) = |{j ∈ N | xj ̸= x′
j }|
9. Incremental evaluation in 1-flip operation
• Using the auxiliary data in memory, we compute the increase
of evaluation function in O(1) time when flipping a variable.
• The auxiliary data are updated only when updating the
current solution.
• The number of evaluating neighbor solutions is much larger
than that of updating the current solution.
×|M|
×|N|
Difference Auxiliary memory Instance data
shortageexcess
≥
≤
10. Incremental evaluation in 2-flip operation
• We only consider the pair of variables satisfying xj=1 ̸= xj2
and Sj1 ∩ Sj2 ̸= ∅ when the current solution x is locally
optimal in NB1(x).
• We compute the increase of evaluation function ∆zj1,j2 (x) in
O(|Sj1 ∩ Sj2 |) time by the following formula.
∆zj1,j2 (x) = ∆z−
j1
(x) + ∆z+
j2
(x) −
∑
i∈Sj1
∩Sj2
∩ ¯S(x)†
(w+
i + w−
i )
≥
≤
-1 +1
† ¯S(x) = {i ∈ M |
∑
j∈N aij xj = 1}
13. Test instances
• We have tested our algorithm on the following SPP instances.
• Run 3600 sec in a single thread on MacBook Pro with Intel
Core i7 2.7GHz and 16GB memory.
• All algorithms were tested on the presolved instances
(removed redundant columns).
original presolved
instance #cst. #var. #cst. #var.
t1716 467 56865 467 11952
t1717 551 73885 551 16428
t1718 523 67796 523 16310
t1719 556 72520 556 15846
t1720 538 69134 538 16195
t1721 357 36039 357 9043
t1722 338 36630 338 6581
ds 656 67732 656 67730
ds-big 1042 174997 1042 173026
ivu06-big 1177 2277736 1177 2197744
ivu59 3436 2569996 3413 2565083
14. Compared to other solvers
• We compare our algorithm with the latest solvers called
CPLEX12.6, SCIP3.1 and LocalSolver3.1.
• We illustrate the relative gap (z(x) − zbest)/z(x) of the
obtained feasible solutions under the hard constraints†.
• We observe that our algorithm achieves comparable upper
bounds to the latest solvers for the large-scale instances.
instance CPLEX12.6 SCIP3.1 LocalSolver3.1 proposed
t1716 8.80% 6.95% infeasible 0.00%
t1717 10.66% 8.63% infeasible 3.15%
t1718 4.27% 0.84% infeasible 1.60%
t1719 6.73% 2.99% infeasible 0.00%
t1720 0.00% 10.76% infeasible 2.45%
t1721 6.78% 1.85% 37.36% 1.32%
t1722 3.92% 0.00% infeasible 0.25%
ds 2.60% 36.44% 84.15% 0.00%
ds-big 55.13% 66.46% 91.24% 0.00%
ivu06-big 19.83% 16.83% 51.93% 0.00%
ivu59 50.55% 57.01% 64.69% 4.15%
†
zbest is the best upper bound among all algorithms and settings
15. Summary
• We develop a data mining approach to reduce the number of
candidates in the large neighborhood deriving the input data
to be solved.
• We construct a k-nearest neighbor graph (and a
corresponding neighbor-list) that identify promising pairs of
flipping variables in the 2-flip neighborhood.
• To save computation time to generate the neighbor-list, we
introduce a lazy construction of the neighbor-list.
• We introduce a naive data mining technique into the proposed
algorithm, but this is the first step to introduce the data
mining and/or machine learning techniques to solve large-scale
hard combinatorial optimization problems efficiently.