parent
10ebfc2086
commit
be0cd98e9d
@ -0,0 +1,22 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
module BB
|
||||||
|
|
||||||
|
frac(x) = x - floor(x)
|
||||||
|
|
||||||
|
include("structs.jl")
|
||||||
|
|
||||||
|
include("nodepool.jl")
|
||||||
|
include("optimize.jl")
|
||||||
|
include("log.jl")
|
||||||
|
include("lp.jl")
|
||||||
|
include("varbranch/hybrid.jl")
|
||||||
|
include("varbranch/infeasibility.jl")
|
||||||
|
include("varbranch/pseudocost.jl")
|
||||||
|
include("varbranch/random.jl")
|
||||||
|
include("varbranch/reliability.jl")
|
||||||
|
include("varbranch/strong.jl")
|
||||||
|
|
||||||
|
end # module
|
||||||
@ -0,0 +1,79 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
using Printf
|
||||||
|
|
||||||
|
function print_progress_header(; detailed_output::Bool)
|
||||||
|
@printf(
|
||||||
|
"%8s %9s %9s %13s %13s %13s %9s %8s",
|
||||||
|
"time",
|
||||||
|
"visited",
|
||||||
|
"pending",
|
||||||
|
"obj",
|
||||||
|
"primal-bound",
|
||||||
|
"dual-bound",
|
||||||
|
"gap",
|
||||||
|
"lp-iter"
|
||||||
|
)
|
||||||
|
if detailed_output
|
||||||
|
@printf(
|
||||||
|
" %6s %6s %-24s %6s %6s %6s",
|
||||||
|
"node",
|
||||||
|
"parent",
|
||||||
|
"branch-var",
|
||||||
|
"b-val",
|
||||||
|
"depth",
|
||||||
|
"iinfes"
|
||||||
|
)
|
||||||
|
end
|
||||||
|
println()
|
||||||
|
flush(stdout)
|
||||||
|
end
|
||||||
|
|
||||||
|
function print_progress(
|
||||||
|
pool::NodePool,
|
||||||
|
node::Node;
|
||||||
|
time_elapsed::Float64,
|
||||||
|
print_interval::Int,
|
||||||
|
detailed_output::Bool,
|
||||||
|
primal_update::Bool,
|
||||||
|
)::Nothing
|
||||||
|
prefix = primal_update ? "*" : " "
|
||||||
|
if (pool.processed % print_interval == 0) || isempty(pool.pending) || primal_update
|
||||||
|
@printf(
|
||||||
|
"%8.2f %1s%9d %9d %13.6e %13.6e %13.6e %9.2e %8d",
|
||||||
|
time_elapsed,
|
||||||
|
prefix,
|
||||||
|
pool.processed,
|
||||||
|
length(pool.processing) + length(pool.pending),
|
||||||
|
node.obj * node.mip.sense,
|
||||||
|
pool.primal_bound * node.mip.sense,
|
||||||
|
pool.dual_bound * node.mip.sense,
|
||||||
|
pool.gap,
|
||||||
|
pool.mip.lp_iterations,
|
||||||
|
)
|
||||||
|
if detailed_output
|
||||||
|
if isempty(node.branch_variables)
|
||||||
|
branch_var_name = "---"
|
||||||
|
branch_value = "---"
|
||||||
|
else
|
||||||
|
branch_var_name = name(node.mip, last(node.branch_variables))
|
||||||
|
L = min(24, length(branch_var_name))
|
||||||
|
branch_var_name = branch_var_name[1:L]
|
||||||
|
branch_value = @sprintf("%.2f", last(node.branch_values))
|
||||||
|
end
|
||||||
|
@printf(
|
||||||
|
" %6d %6s %-24s %6s %6d %6d",
|
||||||
|
node.index,
|
||||||
|
node.parent === nothing ? "---" : @sprintf("%d", node.parent.index),
|
||||||
|
branch_var_name,
|
||||||
|
branch_value,
|
||||||
|
length(node.branch_variables),
|
||||||
|
length(node.fractional_variables)
|
||||||
|
)
|
||||||
|
end
|
||||||
|
println()
|
||||||
|
flush(stdout)
|
||||||
|
end
|
||||||
|
end
|
||||||
@ -0,0 +1,212 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
import Base: values, convert
|
||||||
|
using Base.Threads
|
||||||
|
import Base.Threads: @threads, nthreads, threadid
|
||||||
|
using JuMP
|
||||||
|
using MathOptInterface
|
||||||
|
const MOI = MathOptInterface
|
||||||
|
|
||||||
|
function init(constructor)::MIP
|
||||||
|
return MIP(constructor, Any[nothing for t = 1:nthreads()], Variable[], 1.0, 0)
|
||||||
|
end
|
||||||
|
|
||||||
|
function read!(mip::MIP, filename::AbstractString)::Nothing
|
||||||
|
@threads for t = 1:nthreads()
|
||||||
|
model = read_from_file(filename)
|
||||||
|
mip.optimizers[t] = backend(model)
|
||||||
|
_replace_zero_one!(mip.optimizers[t])
|
||||||
|
if t == 1
|
||||||
|
_assert_supported(mip.optimizers[t])
|
||||||
|
mip.binary_variables = _get_binary_variables(mip.optimizers[t])
|
||||||
|
mip.sense = _get_objective_sense(mip.optimizers[t])
|
||||||
|
end
|
||||||
|
_relax_integrality!(mip.optimizers[t])
|
||||||
|
set_optimizer(model, mip.constructor)
|
||||||
|
set_silent(model)
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
|
|
||||||
|
function _assert_supported(optimizer::MOI.AbstractOptimizer)::Nothing
|
||||||
|
types = MOI.get(optimizer, MOI.ListOfConstraints())
|
||||||
|
for (F, S) in types
|
||||||
|
_assert_supported(F, S)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
function _assert_supported(F::DataType, S::DataType)::Nothing
|
||||||
|
if F in [MOI.ScalarAffineFunction{Float64}, MOI.SingleVariable] && S in [
|
||||||
|
MOI.LessThan{Float64},
|
||||||
|
MOI.GreaterThan{Float64},
|
||||||
|
MOI.EqualTo{Float64},
|
||||||
|
MOI.Interval{Float64},
|
||||||
|
]
|
||||||
|
return
|
||||||
|
end
|
||||||
|
if F in [MOI.SingleVariable] && S in [MOI.Integer, MOI.ZeroOne]
|
||||||
|
return
|
||||||
|
end
|
||||||
|
error("MOI constraint not supported: $F in $S")
|
||||||
|
end
|
||||||
|
|
||||||
|
function _get_objective_sense(optimizer::MOI.AbstractOptimizer)::Float64
|
||||||
|
sense = MOI.get(optimizer, MOI.ObjectiveSense())
|
||||||
|
if sense == MOI.MIN_SENSE
|
||||||
|
return 1.0
|
||||||
|
elseif sense == MOI.MAX_SENSE
|
||||||
|
return -1.0
|
||||||
|
else
|
||||||
|
error("objective sense not supported: $sense")
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
_bounds_constraint(v::Variable) =
|
||||||
|
MOI.ConstraintIndex{MOI.SingleVariable,MOI.Interval{Float64}}(v.index)
|
||||||
|
|
||||||
|
function _replace_zero_one!(optimizer::MOI.AbstractOptimizer)::Nothing
|
||||||
|
constrs_to_delete = MOI.ConstraintIndex[]
|
||||||
|
funcs = MOI.SingleVariable[]
|
||||||
|
sets = Union{MOI.Interval,MOI.Integer}[]
|
||||||
|
for ci in
|
||||||
|
MOI.get(optimizer, MOI.ListOfConstraintIndices{MOI.SingleVariable,MOI.ZeroOne}())
|
||||||
|
func = MOI.get(optimizer, MOI.ConstraintFunction(), ci)
|
||||||
|
var = func.variable
|
||||||
|
push!(constrs_to_delete, ci)
|
||||||
|
push!(funcs, MOI.SingleVariable(var))
|
||||||
|
push!(funcs, MOI.SingleVariable(var))
|
||||||
|
push!(sets, MOI.Interval{Float64}(0.0, 1.0))
|
||||||
|
push!(sets, MOI.Integer())
|
||||||
|
end
|
||||||
|
MOI.delete(optimizer, constrs_to_delete)
|
||||||
|
MOI.add_constraints(optimizer, funcs, sets)
|
||||||
|
return
|
||||||
|
end
|
||||||
|
|
||||||
|
function _get_binary_variables(optimizer::MOI.AbstractOptimizer)::Vector{Variable}
|
||||||
|
vars = Variable[]
|
||||||
|
for ci in
|
||||||
|
MOI.get(optimizer, MOI.ListOfConstraintIndices{MOI.SingleVariable,MOI.Integer}())
|
||||||
|
func = MOI.get(optimizer, MOI.ConstraintFunction(), ci)
|
||||||
|
var = Variable(func.variable.value)
|
||||||
|
|
||||||
|
MOI.is_valid(optimizer, _bounds_constraint(var)) ||
|
||||||
|
error("$var is not interval-constrained")
|
||||||
|
interval = MOI.get(optimizer, MOI.ConstraintSet(), _bounds_constraint(var))
|
||||||
|
interval.lower == 0.0 || error("$var has lb != 0")
|
||||||
|
interval.upper == 1.0 || error("$var has ub != 1")
|
||||||
|
|
||||||
|
push!(vars, var)
|
||||||
|
end
|
||||||
|
return vars
|
||||||
|
end
|
||||||
|
|
||||||
|
function _relax_integrality!(optimizer::MOI.AbstractOptimizer)::Nothing
|
||||||
|
indices =
|
||||||
|
MOI.get(optimizer, MOI.ListOfConstraintIndices{MOI.SingleVariable,MOI.Integer}())
|
||||||
|
MOI.delete(optimizer, indices)
|
||||||
|
end
|
||||||
|
|
||||||
|
"""
|
||||||
|
solve_relaxation(mip::MIP)::Tuple{Symbol, Float64}
|
||||||
|
|
||||||
|
Solve the linear relaxation of `mip` and returns a tuple containing the
|
||||||
|
solution status (either :Optimal or :Infeasible) and the optimal objective
|
||||||
|
value. If the problem is infeasible, the optimal value is Inf for minimization
|
||||||
|
problems and -Inf for maximization problems..
|
||||||
|
"""
|
||||||
|
function solve_relaxation!(mip::MIP)::Tuple{Symbol,Float64}
|
||||||
|
t = threadid()
|
||||||
|
MOI.optimize!(mip.optimizers[t])
|
||||||
|
try
|
||||||
|
mip.lp_iterations += MOI.get(mip.optimizers[t], MOI.SimplexIterations())
|
||||||
|
catch
|
||||||
|
# ignore
|
||||||
|
end
|
||||||
|
status = MOI.get(mip.optimizers[t], MOI.TerminationStatus())
|
||||||
|
if status == MOI.OPTIMAL
|
||||||
|
obj = MOI.get(mip.optimizers[t], MOI.ObjectiveValue())
|
||||||
|
return :Optimal, obj * mip.sense
|
||||||
|
elseif status in [MOI.INFEASIBLE, MOI.INFEASIBLE_OR_UNBOUNDED]
|
||||||
|
return :Infeasible, Inf * mip.sense
|
||||||
|
end
|
||||||
|
error("unknown status: $status")
|
||||||
|
end
|
||||||
|
|
||||||
|
"""
|
||||||
|
values(mip::MIP, vars::Vector{Variable})::Array{Float64}
|
||||||
|
|
||||||
|
Returns a vector `vals` which describes the current primal values for the
|
||||||
|
decision variables `vars`. More specifically, `vals[j]` is the current
|
||||||
|
primal value of `vars[j]`.
|
||||||
|
"""
|
||||||
|
function values(mip::MIP, vars::Vector{Variable})::Array{Float64}
|
||||||
|
return MOI.get(
|
||||||
|
mip.optimizers[threadid()],
|
||||||
|
MOI.VariablePrimal(),
|
||||||
|
convert.(MOI.VariableIndex, vars),
|
||||||
|
)
|
||||||
|
end
|
||||||
|
|
||||||
|
values(mip::MIP) =
|
||||||
|
values(mip, MOI.get(mip.optimizers[threadid()], MOI.ListOfVariableIndices()))
|
||||||
|
|
||||||
|
"""
|
||||||
|
set_bounds!(mip::MIP,
|
||||||
|
vars::Vector{Variable},
|
||||||
|
lb::Array{Float64},
|
||||||
|
ub::Array{Float64})
|
||||||
|
|
||||||
|
Modify the bounds of the given variables. More specifically, sets
|
||||||
|
upper and lower bounds of `vars[j]` to `ub[j]` and `lb[j]`, respectively.
|
||||||
|
"""
|
||||||
|
function set_bounds!(
|
||||||
|
mip::MIP,
|
||||||
|
vars::Vector{Variable},
|
||||||
|
lb::Array{Float64},
|
||||||
|
ub::Array{Float64},
|
||||||
|
)::Nothing
|
||||||
|
t = threadid()
|
||||||
|
MOI.delete(mip.optimizers[t], _bounds_constraint.(vars))
|
||||||
|
funcs = MOI.SingleVariable[]
|
||||||
|
sets = MOI.Interval[]
|
||||||
|
for j = 1:length(vars)
|
||||||
|
push!(funcs, MOI.SingleVariable(vars[j]))
|
||||||
|
push!(sets, MOI.Interval(lb[j], ub[j]))
|
||||||
|
end
|
||||||
|
MOI.add_constraints(mip.optimizers[t], funcs, sets)
|
||||||
|
return
|
||||||
|
end
|
||||||
|
|
||||||
|
"""
|
||||||
|
name(mip::MIP, var::Variable)::String
|
||||||
|
|
||||||
|
Return the name of the decision variable `var`.
|
||||||
|
"""
|
||||||
|
function name(mip::MIP, var::Variable)::String
|
||||||
|
t = threadid()
|
||||||
|
return MOI.get(mip.optimizers[t], MOI.VariableName(), convert(MOI.VariableIndex, var))
|
||||||
|
end
|
||||||
|
|
||||||
|
convert(::Type{MOI.VariableIndex}, v::Variable) = MOI.VariableIndex(v.index)
|
||||||
|
|
||||||
|
"""
|
||||||
|
probe(mip::MIP, var)::Tuple{Float64, Float64}
|
||||||
|
|
||||||
|
Suppose that the LP relaxation of `mip` has been solved and that `var` holds
|
||||||
|
a fractional value `f`. This function returns two numbers corresponding,
|
||||||
|
respectively, to the the optimal values of the LP relaxations having the
|
||||||
|
constraints var=1 and var=0 enforced. If any branch is infeasible, the optimal
|
||||||
|
value for that branch is Inf for minimization problems and -Inf for maximization
|
||||||
|
problems.
|
||||||
|
"""
|
||||||
|
function probe(mip::MIP, var)::Tuple{Float64,Float64}
|
||||||
|
set_bounds!(mip, [var], [1.0], [1.0])
|
||||||
|
status_up, obj_up = solve_relaxation!(mip)
|
||||||
|
set_bounds!(mip, [var], [0.0], [0.0])
|
||||||
|
status_down, obj_down = solve_relaxation!(mip)
|
||||||
|
set_bounds!(mip, [var], [0.0], [1.0])
|
||||||
|
return obj_up * mip.sense, obj_down * mip.sense
|
||||||
|
end
|
||||||
@ -0,0 +1,188 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
using Statistics
|
||||||
|
using DataStructures
|
||||||
|
import Base.Threads: threadid
|
||||||
|
|
||||||
|
function take(
|
||||||
|
pool::NodePool;
|
||||||
|
suggestions::Array{Node} = [],
|
||||||
|
time_remaining::Float64,
|
||||||
|
gap_limit::Float64,
|
||||||
|
node_limit::Int,
|
||||||
|
)::Union{Symbol,Node}
|
||||||
|
t = threadid()
|
||||||
|
lock(pool.lock) do
|
||||||
|
n_processing = length(pool.processing)
|
||||||
|
if (
|
||||||
|
(pool.gap < gap_limit) ||
|
||||||
|
(n_processing + pool.processed >= node_limit) ||
|
||||||
|
(time_remaining < 0)
|
||||||
|
)
|
||||||
|
return :END
|
||||||
|
end
|
||||||
|
if isempty(pool.pending)
|
||||||
|
if isempty(pool.processing)
|
||||||
|
return :END
|
||||||
|
else
|
||||||
|
return :WAIT
|
||||||
|
end
|
||||||
|
else
|
||||||
|
# If one of the suggested nodes is still pending, return it.
|
||||||
|
# This is known in the literature as plunging.
|
||||||
|
for s in suggestions
|
||||||
|
if s in keys(pool.pending)
|
||||||
|
delete!(pool.pending, s)
|
||||||
|
pool.processing[s] = s.obj
|
||||||
|
return s
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# If all suggestions have already been processed
|
||||||
|
# or pruned, find another node based on best bound.
|
||||||
|
node = dequeue!(pool.pending)
|
||||||
|
pool.processing[node] = node.obj
|
||||||
|
return node
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
function offer(
|
||||||
|
pool::NodePool;
|
||||||
|
parent_node::Union{Nothing,Node},
|
||||||
|
child_nodes::Vector{Node},
|
||||||
|
time_elapsed::Float64 = 0.0,
|
||||||
|
print_interval::Int = 100,
|
||||||
|
detailed_output::Bool = false,
|
||||||
|
)::Nothing
|
||||||
|
lock(pool.lock) do
|
||||||
|
primal_update = false
|
||||||
|
|
||||||
|
# Update node.processing and node.processed
|
||||||
|
pool.processed += 1
|
||||||
|
if parent_node !== nothing
|
||||||
|
delete!(pool.processing, parent_node)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Queue child nodes
|
||||||
|
for node in child_nodes
|
||||||
|
if node.status == :Infeasible
|
||||||
|
continue
|
||||||
|
end
|
||||||
|
if node.obj >= pool.primal_bound
|
||||||
|
continue
|
||||||
|
end
|
||||||
|
if isempty(node.fractional_variables)
|
||||||
|
pool.primal_bound = min(pool.primal_bound, node.obj)
|
||||||
|
primal_update = true
|
||||||
|
continue
|
||||||
|
end
|
||||||
|
pool.pending[node] = node.obj
|
||||||
|
end
|
||||||
|
|
||||||
|
# Update dual bound
|
||||||
|
pool.dual_bound = pool.primal_bound
|
||||||
|
if !isempty(pool.pending)
|
||||||
|
pool.dual_bound = min(pool.dual_bound, peek(pool.pending)[2])
|
||||||
|
end
|
||||||
|
if !isempty(pool.processing)
|
||||||
|
pool.dual_bound = min(pool.dual_bound, peek(pool.processing)[2])
|
||||||
|
end
|
||||||
|
|
||||||
|
# Update gap
|
||||||
|
if pool.primal_bound == pool.dual_bound
|
||||||
|
pool.gap = 0
|
||||||
|
else
|
||||||
|
pool.gap = abs((pool.primal_bound - pool.dual_bound) / pool.primal_bound)
|
||||||
|
end
|
||||||
|
|
||||||
|
if parent_node !== nothing
|
||||||
|
# Update branching variable history
|
||||||
|
branch_var = child_nodes[1].branch_variables[end]
|
||||||
|
offset = findfirst(isequal(branch_var), parent_node.fractional_variables)
|
||||||
|
x = parent_node.fractional_values[offset]
|
||||||
|
obj_change_up = child_nodes[1].obj - parent_node.obj
|
||||||
|
obj_change_down = child_nodes[2].obj - parent_node.obj
|
||||||
|
_update_var_history(
|
||||||
|
pool = pool,
|
||||||
|
var = branch_var,
|
||||||
|
x = x,
|
||||||
|
obj_change_down = obj_change_down,
|
||||||
|
obj_change_up = obj_change_up,
|
||||||
|
)
|
||||||
|
|
||||||
|
# Update global history
|
||||||
|
pool.history.avg_pseudocost_up =
|
||||||
|
mean(vh.pseudocost_up for vh in values(pool.var_history))
|
||||||
|
pool.history.avg_pseudocost_down =
|
||||||
|
mean(vh.pseudocost_down for vh in values(pool.var_history))
|
||||||
|
|
||||||
|
# Print progress
|
||||||
|
print_progress(
|
||||||
|
pool,
|
||||||
|
parent_node,
|
||||||
|
time_elapsed = time_elapsed,
|
||||||
|
print_interval = print_interval,
|
||||||
|
detailed_output = detailed_output,
|
||||||
|
primal_update = primal_update,
|
||||||
|
)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
|
|
||||||
|
function _update_var_history(;
|
||||||
|
pool::NodePool,
|
||||||
|
var::Variable,
|
||||||
|
x::Float64,
|
||||||
|
obj_change_down::Float64,
|
||||||
|
obj_change_up::Float64,
|
||||||
|
)::Nothing
|
||||||
|
# Create new history entry
|
||||||
|
if var ∉ keys(pool.var_history)
|
||||||
|
pool.var_history[var] = VariableHistory()
|
||||||
|
end
|
||||||
|
varhist = pool.var_history[var]
|
||||||
|
|
||||||
|
# Push fractional value
|
||||||
|
push!(varhist.fractional_values, x)
|
||||||
|
|
||||||
|
# Push objective value changes
|
||||||
|
push!(varhist.obj_change_up, obj_change_up)
|
||||||
|
push!(varhist.obj_change_down, obj_change_down)
|
||||||
|
|
||||||
|
# Push objective change ratios
|
||||||
|
f_up = x - floor(x)
|
||||||
|
f_down = ceil(x) - x
|
||||||
|
if isfinite(obj_change_up)
|
||||||
|
push!(varhist.obj_ratio_up, obj_change_up / f_up)
|
||||||
|
end
|
||||||
|
if isfinite(obj_change_down)
|
||||||
|
push!(varhist.obj_ratio_down, obj_change_down / f_down)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Update variable pseudocosts
|
||||||
|
varhist.pseudocost_up = 0.0
|
||||||
|
varhist.pseudocost_down = 0.0
|
||||||
|
if !isempty(varhist.obj_ratio_up)
|
||||||
|
varhist.pseudocost_up = sum(varhist.obj_ratio_up) / length(varhist.obj_ratio_up)
|
||||||
|
end
|
||||||
|
if !isempty(varhist.obj_ratio_down)
|
||||||
|
varhist.pseudocost_down =
|
||||||
|
sum(varhist.obj_ratio_down) / length(varhist.obj_ratio_down)
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
|
|
||||||
|
function generate_indices(pool::NodePool, n::Int)::Vector{Int}
|
||||||
|
lock(pool.lock) do
|
||||||
|
result = Int[]
|
||||||
|
for i = 1:n
|
||||||
|
push!(result, pool.next_index)
|
||||||
|
pool.next_index += 1
|
||||||
|
end
|
||||||
|
return result
|
||||||
|
end
|
||||||
|
end
|
||||||
@ -0,0 +1,125 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
using Printf
|
||||||
|
using Base.Threads
|
||||||
|
import Base.Threads: @threads, nthreads, threadid
|
||||||
|
|
||||||
|
function solve!(
|
||||||
|
mip::MIP;
|
||||||
|
time_limit::Float64 = Inf,
|
||||||
|
node_limit::Int = typemax(Int),
|
||||||
|
gap_limit::Float64 = 1e-4,
|
||||||
|
print_interval::Int = 5,
|
||||||
|
initial_primal_bound::Float64 = Inf,
|
||||||
|
detailed_output::Bool = false,
|
||||||
|
branch_rule::VariableBranchingRule = HybridBranching(),
|
||||||
|
)::NodePool
|
||||||
|
time_initial = time()
|
||||||
|
pool = NodePool(mip = mip)
|
||||||
|
pool.primal_bound = initial_primal_bound
|
||||||
|
print_progress_header(detailed_output = detailed_output)
|
||||||
|
|
||||||
|
root_node = _create_node(mip)
|
||||||
|
if isempty(root_node.fractional_variables)
|
||||||
|
println("root relaxation is integer feasible")
|
||||||
|
pool.dual_bound = root_node.obj
|
||||||
|
pool.primal_bound = root_node.obj
|
||||||
|
return pool
|
||||||
|
end
|
||||||
|
|
||||||
|
offer(pool, parent_node = nothing, child_nodes = [root_node])
|
||||||
|
@threads for t = 1:nthreads()
|
||||||
|
child_one, child_zero, suggestions = nothing, nothing, Node[]
|
||||||
|
while true
|
||||||
|
time_elapsed = time() - time_initial
|
||||||
|
if child_one !== nothing
|
||||||
|
suggestions = Node[child_one, child_zero]
|
||||||
|
end
|
||||||
|
node = take(
|
||||||
|
pool,
|
||||||
|
suggestions = suggestions,
|
||||||
|
time_remaining = time_limit - time_elapsed,
|
||||||
|
node_limit = node_limit,
|
||||||
|
gap_limit = gap_limit,
|
||||||
|
)
|
||||||
|
if node == :END
|
||||||
|
break
|
||||||
|
elseif node == :WAIT
|
||||||
|
sleep(0.1)
|
||||||
|
continue
|
||||||
|
else
|
||||||
|
ids = generate_indices(pool, 2)
|
||||||
|
branch_variable = find_branching_var(branch_rule, node, pool)
|
||||||
|
child_zero = _create_node(
|
||||||
|
mip,
|
||||||
|
index = ids[1],
|
||||||
|
parent = node,
|
||||||
|
branch_variable = branch_variable,
|
||||||
|
branch_value = 0.0,
|
||||||
|
)
|
||||||
|
child_one = _create_node(
|
||||||
|
mip,
|
||||||
|
index = ids[2],
|
||||||
|
parent = node,
|
||||||
|
branch_variable = branch_variable,
|
||||||
|
branch_value = 1.0,
|
||||||
|
)
|
||||||
|
offer(
|
||||||
|
pool,
|
||||||
|
parent_node = node,
|
||||||
|
child_nodes = [child_one, child_zero],
|
||||||
|
time_elapsed = time_elapsed,
|
||||||
|
print_interval = print_interval,
|
||||||
|
detailed_output = detailed_output,
|
||||||
|
)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return pool
|
||||||
|
end
|
||||||
|
|
||||||
|
function _create_node(
|
||||||
|
mip;
|
||||||
|
index::Int = 0,
|
||||||
|
parent::Union{Nothing,Node} = nothing,
|
||||||
|
branch_variable::Union{Nothing,Variable} = nothing,
|
||||||
|
branch_value::Union{Nothing,Float64} = nothing,
|
||||||
|
)::Node
|
||||||
|
if parent === nothing
|
||||||
|
branch_variables = Variable[]
|
||||||
|
branch_values = Float64[]
|
||||||
|
depth = 1
|
||||||
|
else
|
||||||
|
branch_variables = [parent.branch_variables; branch_variable]
|
||||||
|
branch_values = [parent.branch_values; branch_value]
|
||||||
|
depth = parent.depth + 1
|
||||||
|
end
|
||||||
|
set_bounds!(mip, branch_variables, branch_values, branch_values)
|
||||||
|
status, obj = solve_relaxation!(mip)
|
||||||
|
if status == :Optimal
|
||||||
|
vals = values(mip, mip.binary_variables)
|
||||||
|
fractional_indices =
|
||||||
|
[j for j in 1:length(mip.binary_variables) if 1e-6 < vals[j] < 1 - 1e-6]
|
||||||
|
fractional_values = vals[fractional_indices]
|
||||||
|
fractional_variables = mip.binary_variables[fractional_indices]
|
||||||
|
else
|
||||||
|
fractional_variables = Variable[]
|
||||||
|
fractional_values = Float64[]
|
||||||
|
end
|
||||||
|
n_branch = length(branch_variables)
|
||||||
|
set_bounds!(mip, branch_variables, zeros(n_branch), ones(n_branch))
|
||||||
|
return Node(
|
||||||
|
mip,
|
||||||
|
index,
|
||||||
|
depth,
|
||||||
|
obj,
|
||||||
|
status,
|
||||||
|
branch_variables,
|
||||||
|
branch_values,
|
||||||
|
fractional_variables,
|
||||||
|
fractional_values,
|
||||||
|
parent,
|
||||||
|
)
|
||||||
|
end
|
||||||
@ -0,0 +1,70 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
using DataStructures
|
||||||
|
abstract type VariableBranchingRule end
|
||||||
|
|
||||||
|
struct Variable
|
||||||
|
index::Any
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct MIP
|
||||||
|
constructor
|
||||||
|
optimizers::Vector
|
||||||
|
binary_variables::Vector{Variable}
|
||||||
|
sense::Float64
|
||||||
|
lp_iterations::Int64
|
||||||
|
end
|
||||||
|
|
||||||
|
struct Node
|
||||||
|
mip::MIP
|
||||||
|
index::Int
|
||||||
|
depth::Int
|
||||||
|
obj::Float64
|
||||||
|
status::Symbol
|
||||||
|
branch_variables::Array{Variable}
|
||||||
|
branch_values::Array{Float64}
|
||||||
|
fractional_variables::Array{Variable}
|
||||||
|
fractional_values::Array{Float64}
|
||||||
|
parent::Union{Nothing,Node}
|
||||||
|
end
|
||||||
|
|
||||||
|
Base.@kwdef mutable struct History
|
||||||
|
avg_pseudocost_up::Float64 = 1.0
|
||||||
|
avg_pseudocost_down::Float64 = 1.0
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct VariableHistory
|
||||||
|
fractional_values::Array{Float64}
|
||||||
|
obj_change_up::Array{Float64}
|
||||||
|
obj_change_down::Array{Float64}
|
||||||
|
obj_ratio_up::Array{Float64}
|
||||||
|
obj_ratio_down::Array{Float64}
|
||||||
|
pseudocost_up::Float64
|
||||||
|
pseudocost_down::Float64
|
||||||
|
|
||||||
|
VariableHistory() = new(
|
||||||
|
Float64[], # fractional_values
|
||||||
|
Float64[], # obj_change_up
|
||||||
|
Float64[], # obj_change_down
|
||||||
|
Float64[], # obj_ratio_up
|
||||||
|
Float64[], # obj_ratio_up
|
||||||
|
0.0, # pseudocost_up
|
||||||
|
0.0, # pseudocost_down
|
||||||
|
)
|
||||||
|
end
|
||||||
|
|
||||||
|
Base.@kwdef mutable struct NodePool
|
||||||
|
mip::MIP
|
||||||
|
pending::PriorityQueue{Node,Float64} = PriorityQueue{Node,Float64}()
|
||||||
|
processing::PriorityQueue{Node,Float64} = PriorityQueue{Node,Float64}()
|
||||||
|
processed::Int = 0
|
||||||
|
next_index::Int = 1
|
||||||
|
lock::ReentrantLock = ReentrantLock()
|
||||||
|
primal_bound::Float64 = Inf
|
||||||
|
dual_bound::Float64 = Inf
|
||||||
|
gap::Float64 = Inf
|
||||||
|
history::History = History()
|
||||||
|
var_history::Dict{Variable,VariableHistory} = Dict()
|
||||||
|
end
|
||||||
@ -0,0 +1,31 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
"""
|
||||||
|
HybridBranching(depth_cutoff::Int,
|
||||||
|
shallow_rule::VariableBranchingRule,
|
||||||
|
deep_rule::::VariableBranchingRule)
|
||||||
|
|
||||||
|
Branching strategy that switches between two variable branching strategies,
|
||||||
|
according to the depth of the node.
|
||||||
|
|
||||||
|
More specifically, if `node.depth <= depth_cutoff`, then `shallow_rule` is
|
||||||
|
applied. Otherwise, `deep_rule` is applied.
|
||||||
|
"""
|
||||||
|
mutable struct HybridBranching <: VariableBranchingRule
|
||||||
|
depth_cutoff::Int
|
||||||
|
shallow_rule::VariableBranchingRule
|
||||||
|
deep_rule::VariableBranchingRule
|
||||||
|
end
|
||||||
|
|
||||||
|
HybridBranching(depth_cutoff::Int = 10) =
|
||||||
|
HybridBranching(depth_cutoff, StrongBranching(), PseudocostBranching())
|
||||||
|
|
||||||
|
function find_branching_var(rule::HybridBranching, node::Node, pool::NodePool)::Variable
|
||||||
|
if node.depth <= rule.depth_cutoff
|
||||||
|
return find_branching_var(rule.shallow_rule, node, pool)
|
||||||
|
else
|
||||||
|
return find_branching_var(rule.deep_rule, node, pool)
|
||||||
|
end
|
||||||
|
end
|
||||||
@ -0,0 +1,54 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
"""
|
||||||
|
FirstInfeasibleBranching()
|
||||||
|
|
||||||
|
Branching rule that always selects the first fractional variable.
|
||||||
|
"""
|
||||||
|
struct FirstInfeasibleBranching <: VariableBranchingRule end
|
||||||
|
|
||||||
|
function find_branching_var(
|
||||||
|
rule::FirstInfeasibleBranching,
|
||||||
|
node::Node,
|
||||||
|
pool::NodePool,
|
||||||
|
)::Variable
|
||||||
|
return node.fractional_variables[1]
|
||||||
|
end
|
||||||
|
|
||||||
|
"""
|
||||||
|
LeastInfeasibleBranching()
|
||||||
|
|
||||||
|
Branching strategy that select the fractional variable whose value is the closest
|
||||||
|
to an integral value.
|
||||||
|
"""
|
||||||
|
struct LeastInfeasibleBranching <: VariableBranchingRule end
|
||||||
|
|
||||||
|
function find_branching_var(
|
||||||
|
rule::LeastInfeasibleBranching,
|
||||||
|
node::Node,
|
||||||
|
pool::NodePool,
|
||||||
|
)::Variable
|
||||||
|
scores = [max(v - floor(v), ceil(v) - v) for v in node.fractional_values]
|
||||||
|
_, max_offset = findmax(scores)
|
||||||
|
return node.fractional_variables[max_offset]
|
||||||
|
end
|
||||||
|
|
||||||
|
"""
|
||||||
|
MostInfeasibleBranching()
|
||||||
|
|
||||||
|
Branching strategy that selects the fractional variable whose value is closest
|
||||||
|
to 1/2.
|
||||||
|
"""
|
||||||
|
struct MostInfeasibleBranching <: VariableBranchingRule end
|
||||||
|
|
||||||
|
function find_branching_var(
|
||||||
|
rule::MostInfeasibleBranching,
|
||||||
|
node::Node,
|
||||||
|
pool::NodePool,
|
||||||
|
)::Variable
|
||||||
|
scores = [min(v - floor(v), ceil(v) - v) for v in node.fractional_values]
|
||||||
|
_, max_offset = findmax(scores)
|
||||||
|
return node.fractional_variables[max_offset]
|
||||||
|
end
|
||||||
@ -0,0 +1,45 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
"""
|
||||||
|
PseudocostBranching()
|
||||||
|
|
||||||
|
Branching strategy that uses historical changes in objective value to estimate
|
||||||
|
strong branching scores at lower computational cost.
|
||||||
|
"""
|
||||||
|
struct PseudocostBranching <: VariableBranchingRule end
|
||||||
|
|
||||||
|
function find_branching_var(rule::PseudocostBranching, node::Node, pool::NodePool)::Variable
|
||||||
|
scores = [
|
||||||
|
_pseudocost_score(
|
||||||
|
node,
|
||||||
|
pool,
|
||||||
|
node.fractional_variables[j],
|
||||||
|
node.fractional_values[j],
|
||||||
|
) for j = 1:length(node.fractional_variables)
|
||||||
|
]
|
||||||
|
_, max_offset = findmax(scores)
|
||||||
|
return node.fractional_variables[max_offset]
|
||||||
|
end
|
||||||
|
|
||||||
|
function _pseudocost_score(
|
||||||
|
node::Node,
|
||||||
|
pool::NodePool,
|
||||||
|
var::Variable,
|
||||||
|
x::Float64,
|
||||||
|
)::Tuple{Float64,Int}
|
||||||
|
f_up = x - floor(x)
|
||||||
|
f_down = ceil(x) - x
|
||||||
|
pseudo_up = pool.history.avg_pseudocost_up * f_up
|
||||||
|
pseudo_down = pool.history.avg_pseudocost_down * f_down
|
||||||
|
if var in keys(pool.var_history)
|
||||||
|
if isfinite(pool.var_history[var].pseudocost_up)
|
||||||
|
pseudo_up = pool.var_history[var].pseudocost_up * f_up
|
||||||
|
end
|
||||||
|
if isfinite(pool.var_history[var].pseudocost_down)
|
||||||
|
pseudo_down = pool.var_history[var].pseudocost_down * f_down
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return (pseudo_up * f_up * pseudo_down * f_down, var.index)
|
||||||
|
end
|
||||||
@ -0,0 +1,17 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
using Random
|
||||||
|
|
||||||
|
|
||||||
|
"""
|
||||||
|
RandomBranching()
|
||||||
|
|
||||||
|
Branching strategy that picks a fractional variable randomly.
|
||||||
|
"""
|
||||||
|
struct RandomBranching <: VariableBranchingRule end
|
||||||
|
|
||||||
|
function find_branching_var(rule::RandomBranching, node::Node, pool::NodePool)::Variable
|
||||||
|
return shuffle(node.fractional_variables)[1]
|
||||||
|
end
|
||||||
@ -0,0 +1,115 @@
|
|||||||
|
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
||||||
|
# Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
|
||||||
|
# Released under the modified BSD license. See COPYING.md for more details.
|
||||||
|
|
||||||
|
using Clp
|
||||||
|
using JuMP
|
||||||
|
using Test
|
||||||
|
using MIPLearn.BB
|
||||||
|
|
||||||
|
basepath = @__DIR__
|
||||||
|
|
||||||
|
function runtests(optimizer_name, optimizer; large = true)
|
||||||
|
@testset "Solve ($optimizer_name)" begin
|
||||||
|
@testset "interface" begin
|
||||||
|
filename = "$basepath/../fixtures/danoint.mps.gz"
|
||||||
|
|
||||||
|
mip = BB.init(optimizer)
|
||||||
|
BB.read!(mip, filename)
|
||||||
|
|
||||||
|
@test mip.sense == 1.0
|
||||||
|
@test length(mip.binary_variables) == 56
|
||||||
|
|
||||||
|
status, obj = BB.solve_relaxation!(mip)
|
||||||
|
@test status == :Optimal
|
||||||
|
@test round(obj, digits = 6) == 62.637280
|
||||||
|
|
||||||
|
@test BB.name(mip, mip.binary_variables[1]) == "xab"
|
||||||
|
@test BB.name(mip, mip.binary_variables[2]) == "xac"
|
||||||
|
@test BB.name(mip, mip.binary_variables[3]) == "xad"
|
||||||
|
|
||||||
|
vals = BB.values(mip, mip.binary_variables)
|
||||||
|
@test round(vals[1], digits = 6) == 0.046933
|
||||||
|
@test round(vals[2], digits = 6) == 0.000841
|
||||||
|
@test round(vals[3], digits = 6) == 0.248696
|
||||||
|
|
||||||
|
# Probe (up and down are feasible)
|
||||||
|
probe_up, probe_down = BB.probe(mip, mip.binary_variables[1])
|
||||||
|
@test round(probe_down, digits = 6) == 62.690000
|
||||||
|
@test round(probe_up, digits = 6) == 62.714100
|
||||||
|
|
||||||
|
# Fix one variable to zero
|
||||||
|
BB.set_bounds!(mip, mip.binary_variables[1:1], [0.0], [0.0])
|
||||||
|
status, obj = BB.solve_relaxation!(mip)
|
||||||
|
@test status == :Optimal
|
||||||
|
@test round(obj, digits = 6) == 62.690000
|
||||||
|
|
||||||
|
# Fix one variable to one and another variable variable to zero
|
||||||
|
BB.set_bounds!(mip, mip.binary_variables[1:2], [1.0, 0.0], [1.0, 0.0])
|
||||||
|
status, obj = BB.solve_relaxation!(mip)
|
||||||
|
@test status == :Optimal
|
||||||
|
@test round(obj, digits = 6) == 62.714777
|
||||||
|
|
||||||
|
# Probe (up is infeasible, down is feasible)
|
||||||
|
BB.set_bounds!(
|
||||||
|
mip,
|
||||||
|
mip.binary_variables[1:3],
|
||||||
|
[1.0, 1.0, 0.0],
|
||||||
|
[1.0, 1.0, 1.0],
|
||||||
|
)
|
||||||
|
status, obj = BB.solve_relaxation!(mip)
|
||||||
|
@test status == :Optimal
|
||||||
|
probe_up, probe_down = BB.probe(mip, mip.binary_variables[3])
|
||||||
|
@test round(probe_up, digits = 6) == Inf
|
||||||
|
@test round(probe_down, digits = 6) == 63.073992
|
||||||
|
|
||||||
|
# Fix all binary variables to one, making problem infeasible
|
||||||
|
N = length(mip.binary_variables)
|
||||||
|
BB.set_bounds!(mip, mip.binary_variables, ones(N), ones(N))
|
||||||
|
status, obj = BB.solve_relaxation!(mip)
|
||||||
|
@test status == :Infeasible
|
||||||
|
@test obj == Inf
|
||||||
|
|
||||||
|
# Restore original problem
|
||||||
|
N = length(mip.binary_variables)
|
||||||
|
BB.set_bounds!(mip, mip.binary_variables, zeros(N), ones(N))
|
||||||
|
status, obj = BB.solve_relaxation!(mip)
|
||||||
|
@test status == :Optimal
|
||||||
|
@test round(obj, digits = 6) == 62.637280
|
||||||
|
end
|
||||||
|
|
||||||
|
@testset "varbranch" begin
|
||||||
|
branch_rules = [
|
||||||
|
BB.RandomBranching(),
|
||||||
|
BB.FirstInfeasibleBranching(),
|
||||||
|
BB.LeastInfeasibleBranching(),
|
||||||
|
BB.MostInfeasibleBranching(),
|
||||||
|
BB.PseudocostBranching(),
|
||||||
|
BB.StrongBranching(),
|
||||||
|
BB.ReliabilityBranching(),
|
||||||
|
BB.HybridBranching(),
|
||||||
|
]
|
||||||
|
for branch_rule in branch_rules
|
||||||
|
filename = "$basepath/../fixtures/vpm2.mps.gz"
|
||||||
|
mip = BB.init(optimizer)
|
||||||
|
BB.read!(mip, filename)
|
||||||
|
@info optimizer_name, branch_rule
|
||||||
|
@time BB.solve!(
|
||||||
|
mip,
|
||||||
|
initial_primal_bound = 13.75,
|
||||||
|
print_interval = 10,
|
||||||
|
node_limit = 100,
|
||||||
|
branch_rule = branch_rule,
|
||||||
|
)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
@testset "BB" begin
|
||||||
|
@time runtests("Clp", Clp.Optimizer)
|
||||||
|
if is_gurobi_available
|
||||||
|
using Gurobi
|
||||||
|
@time runtests("Gurobi", Gurobi.Optimizer)
|
||||||
|
end
|
||||||
|
end
|
||||||
Binary file not shown.
Binary file not shown.
Loading…
Reference in new issue