You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
370 lines
13 KiB
370 lines
13 KiB
# MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
|
|
# Copyright (C) 2020-2022, UChicago Argonne, LLC. All rights reserved.
|
|
# Released under the modified BSD license. See COPYING.md for more details.
|
|
|
|
import logging
|
|
import json
|
|
from typing import Dict, Optional, Callable, Any, List
|
|
|
|
import gurobipy as gp
|
|
from gurobipy import GRB, GurobiError
|
|
import numpy as np
|
|
from scipy.sparse import lil_matrix
|
|
|
|
from miplearn.h5 import H5File
|
|
from miplearn.solvers.abstract import AbstractModel
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _gurobi_callback(model: AbstractModel, gp_model: gp.Model, where: int) -> None:
|
|
assert isinstance(gp_model, gp.Model)
|
|
|
|
# Lazy constraints
|
|
if model._lazy_separate is not None:
|
|
assert model._lazy_enforce is not None
|
|
assert model._lazy is not None
|
|
if where == GRB.Callback.MIPSOL:
|
|
model._where = model.WHERE_LAZY
|
|
violations = model._lazy_separate(model)
|
|
if len(violations) > 0:
|
|
model._lazy.extend(violations)
|
|
model._lazy_enforce(model, violations)
|
|
|
|
# User cuts
|
|
if model._cuts_separate is not None:
|
|
assert model._cuts_enforce is not None
|
|
assert model._cuts is not None
|
|
if where == GRB.Callback.MIPNODE:
|
|
status = gp_model.cbGet(GRB.Callback.MIPNODE_STATUS)
|
|
if status == GRB.OPTIMAL:
|
|
model._where = model.WHERE_CUTS
|
|
if model._cuts_aot is not None:
|
|
violations = model._cuts_aot
|
|
model._cuts_aot = None
|
|
logger.info(f"Enforcing {len(violations)} cuts ahead-of-time...")
|
|
else:
|
|
violations = model._cuts_separate(model)
|
|
if len(violations) > 0:
|
|
model._cuts.extend(violations)
|
|
model._cuts_enforce(model, violations)
|
|
|
|
# Cleanup
|
|
model._where = model.WHERE_DEFAULT
|
|
|
|
|
|
def _gurobi_add_constr(gp_model: gp.Model, where: str, constr: Any) -> None:
|
|
if where == AbstractModel.WHERE_LAZY:
|
|
gp_model.cbLazy(constr)
|
|
elif where == AbstractModel.WHERE_CUTS:
|
|
gp_model.cbCut(constr)
|
|
else:
|
|
gp_model.addConstr(constr)
|
|
|
|
|
|
def _gurobi_set_required_params(model: AbstractModel, gp_model: gp.Model) -> None:
|
|
# Required parameters for lazy constraints
|
|
if model._lazy_enforce is not None:
|
|
gp_model.setParam("PreCrush", 1)
|
|
gp_model.setParam("LazyConstraints", 1)
|
|
# Required parameters for user cuts
|
|
if model._cuts_enforce is not None:
|
|
gp_model.setParam("PreCrush", 1)
|
|
|
|
|
|
class GurobiModel(AbstractModel):
|
|
_supports_basis_status = True
|
|
_supports_sensitivity_analysis = True
|
|
_supports_node_count = True
|
|
_supports_solution_pool = True
|
|
|
|
def __init__(
|
|
self,
|
|
inner: gp.Model,
|
|
lazy_separate: Optional[Callable] = None,
|
|
lazy_enforce: Optional[Callable] = None,
|
|
cuts_separate: Optional[Callable] = None,
|
|
cuts_enforce: Optional[Callable] = None,
|
|
) -> None:
|
|
super().__init__()
|
|
self._lazy_separate = lazy_separate
|
|
self._lazy_enforce = lazy_enforce
|
|
self._cuts_separate = cuts_separate
|
|
self._cuts_enforce = cuts_enforce
|
|
self.inner = inner
|
|
|
|
def add_constrs(
|
|
self,
|
|
var_names: np.ndarray,
|
|
constrs_lhs: np.ndarray,
|
|
constrs_sense: np.ndarray,
|
|
constrs_rhs: np.ndarray,
|
|
stats: Optional[Dict] = None,
|
|
) -> None:
|
|
assert len(var_names.shape) == 1
|
|
nvars = len(var_names)
|
|
assert len(constrs_lhs.shape) == 2
|
|
nconstrs = constrs_lhs.shape[0]
|
|
assert constrs_lhs.shape[1] == nvars
|
|
assert constrs_sense.shape == (nconstrs,)
|
|
assert constrs_rhs.shape == (nconstrs,)
|
|
|
|
gp_vars = [self.inner.getVarByName(var_name.decode()) for var_name in var_names]
|
|
self.inner.addMConstr(constrs_lhs, gp_vars, constrs_sense, constrs_rhs)
|
|
|
|
if stats is not None:
|
|
if "Added constraints" not in stats:
|
|
stats["Added constraints"] = 0
|
|
stats["Added constraints"] += nconstrs
|
|
|
|
def add_constr(self, constr: Any) -> None:
|
|
_gurobi_add_constr(self.inner, self._where, constr)
|
|
|
|
def extract_after_load(self, h5: H5File) -> None:
|
|
"""
|
|
Given a model that has just been loaded, extracts static problem
|
|
features, such as variable names and types, objective coefficients, etc.
|
|
"""
|
|
self.inner.update()
|
|
self._extract_after_load_vars(h5)
|
|
self._extract_after_load_constrs(h5)
|
|
h5.put_scalar("static_sense", "min" if self.inner.modelSense > 0 else "max")
|
|
h5.put_scalar("static_obj_offset", self.inner.objCon)
|
|
|
|
def extract_after_lp(self, h5: H5File) -> None:
|
|
"""
|
|
Given a linear programming model that has just been solved, extracts
|
|
dynamic problem features, such as optimal LP solution, basis status,
|
|
etc.
|
|
"""
|
|
self._extract_after_lp_vars(h5)
|
|
self._extract_after_lp_constrs(h5)
|
|
h5.put_scalar("lp_obj_value", self.inner.objVal)
|
|
h5.put_scalar("lp_wallclock_time", self.inner.runtime)
|
|
|
|
def extract_after_mip(self, h5: H5File) -> None:
|
|
"""
|
|
Given a mixed-integer linear programming model that has just been
|
|
solved, extracts dynamic problem features, such as optimal MIP solution.
|
|
"""
|
|
h5.put_scalar("mip_wallclock_time", self.inner.runtime)
|
|
h5.put_scalar("mip_node_count", self.inner.nodeCount)
|
|
if self.inner.status == GRB.INFEASIBLE:
|
|
return
|
|
gp_vars = self.inner.getVars()
|
|
gp_constrs = self.inner.getConstrs()
|
|
h5.put_array(
|
|
"mip_var_values",
|
|
np.array(self.inner.getAttr("x", gp_vars), dtype=float),
|
|
)
|
|
h5.put_array(
|
|
"mip_constr_slacks",
|
|
np.abs(np.array(self.inner.getAttr("slack", gp_constrs), dtype=float)),
|
|
)
|
|
h5.put_scalar("mip_obj_value", self.inner.objVal)
|
|
h5.put_scalar("mip_obj_bound", self.inner.objBound)
|
|
try:
|
|
h5.put_scalar("mip_gap", self.inner.mipGap)
|
|
except AttributeError:
|
|
pass
|
|
self._extract_after_mip_solution_pool(h5)
|
|
if self._lazy is not None:
|
|
h5.put_scalar("mip_lazy", json.dumps(self._lazy))
|
|
if self._cuts is not None:
|
|
h5.put_scalar("mip_cuts", json.dumps(self._cuts))
|
|
|
|
def fix_variables(
|
|
self,
|
|
var_names: np.ndarray,
|
|
var_values: np.ndarray,
|
|
stats: Optional[Dict] = None,
|
|
) -> None:
|
|
assert len(var_values.shape) == 1
|
|
assert len(var_values.shape) == 1
|
|
assert var_names.shape == var_values.shape
|
|
|
|
n_fixed = 0
|
|
for (var_idx, var_name) in enumerate(var_names):
|
|
var_val = var_values[var_idx]
|
|
if np.isfinite(var_val):
|
|
var = self.inner.getVarByName(var_name.decode())
|
|
var.vtype = "C"
|
|
var.lb = var_val
|
|
var.ub = var_val
|
|
n_fixed += 1
|
|
if stats is not None:
|
|
stats["Fixed variables"] = n_fixed
|
|
|
|
def optimize(self) -> None:
|
|
self._lazy = []
|
|
self._cuts = []
|
|
|
|
def callback(_: gp.Model, where: int) -> None:
|
|
_gurobi_callback(self, self.inner, where)
|
|
|
|
_gurobi_set_required_params(self, self.inner)
|
|
|
|
if self.lazy_enforce is not None or self.cuts_enforce is not None:
|
|
self.inner.optimize(callback)
|
|
else:
|
|
self.inner.optimize()
|
|
|
|
def relax(self) -> "GurobiModel":
|
|
return GurobiModel(self.inner.relax())
|
|
|
|
def set_time_limit(self, time_limit_sec: float) -> None:
|
|
self.inner.params.timeLimit = time_limit_sec
|
|
|
|
def set_warm_starts(
|
|
self,
|
|
var_names: np.ndarray,
|
|
var_values: np.ndarray,
|
|
stats: Optional[Dict] = None,
|
|
) -> None:
|
|
assert len(var_values.shape) == 2
|
|
(n_starts, n_vars) = var_values.shape
|
|
assert len(var_names.shape) == 1
|
|
assert var_names.shape[0] == n_vars
|
|
|
|
self.inner.numStart = n_starts
|
|
for start_idx in range(n_starts):
|
|
self.inner.params.startNumber = start_idx
|
|
for (var_idx, var_name) in enumerate(var_names):
|
|
var_val = var_values[start_idx, var_idx]
|
|
if np.isfinite(var_val):
|
|
var = self.inner.getVarByName(var_name.decode())
|
|
var.start = var_val
|
|
|
|
if stats is not None:
|
|
stats["WS: Count"] = n_starts
|
|
stats["WS: Number of variables set"] = (
|
|
np.isfinite(var_values).mean(axis=0).sum()
|
|
)
|
|
|
|
def _extract_after_load_vars(self, h5: H5File) -> None:
|
|
gp_vars = self.inner.getVars()
|
|
for (h5_field, gp_field) in {
|
|
"static_var_names": "varName",
|
|
"static_var_types": "vtype",
|
|
}.items():
|
|
h5.put_array(
|
|
h5_field, np.array(self.inner.getAttr(gp_field, gp_vars), dtype="S")
|
|
)
|
|
for (h5_field, gp_field) in {
|
|
"static_var_upper_bounds": "ub",
|
|
"static_var_lower_bounds": "lb",
|
|
"static_var_obj_coeffs": "obj",
|
|
}.items():
|
|
h5.put_array(
|
|
h5_field, np.array(self.inner.getAttr(gp_field, gp_vars), dtype=float)
|
|
)
|
|
|
|
def _extract_after_load_constrs(self, h5: H5File) -> None:
|
|
gp_constrs = self.inner.getConstrs()
|
|
gp_vars = self.inner.getVars()
|
|
rhs = np.array(self.inner.getAttr("rhs", gp_constrs), dtype=float)
|
|
senses = np.array(self.inner.getAttr("sense", gp_constrs), dtype="S")
|
|
names = np.array(self.inner.getAttr("constrName", gp_constrs), dtype="S")
|
|
nrows, ncols = len(gp_constrs), len(gp_vars)
|
|
tmp = lil_matrix((nrows, ncols), dtype=float)
|
|
for (i, gp_constr) in enumerate(gp_constrs):
|
|
expr = self.inner.getRow(gp_constr)
|
|
for j in range(expr.size()):
|
|
tmp[i, expr.getVar(j).index] = expr.getCoeff(j)
|
|
lhs = tmp.tocoo()
|
|
|
|
h5.put_array("static_constr_names", names)
|
|
h5.put_array("static_constr_rhs", rhs)
|
|
h5.put_array("static_constr_sense", senses)
|
|
h5.put_sparse("static_constr_lhs", lhs)
|
|
|
|
def _extract_after_lp_vars(self, h5: H5File) -> None:
|
|
def _parse_gurobi_vbasis(b: int) -> str:
|
|
if b == 0:
|
|
return "B"
|
|
elif b == -1:
|
|
return "L"
|
|
elif b == -2:
|
|
return "U"
|
|
elif b == -3:
|
|
return "S"
|
|
else:
|
|
raise Exception(f"unknown vbasis: {b}")
|
|
|
|
gp_vars = self.inner.getVars()
|
|
h5.put_array(
|
|
"lp_var_basis_status",
|
|
np.array(
|
|
[
|
|
_parse_gurobi_vbasis(b)
|
|
for b in self.inner.getAttr("vbasis", gp_vars)
|
|
],
|
|
dtype="S",
|
|
),
|
|
)
|
|
for (h5_field, gp_field) in {
|
|
"lp_var_reduced_costs": "rc",
|
|
"lp_var_sa_obj_up": "saobjUp",
|
|
"lp_var_sa_obj_down": "saobjLow",
|
|
"lp_var_sa_ub_up": "saubUp",
|
|
"lp_var_sa_ub_down": "saubLow",
|
|
"lp_var_sa_lb_up": "salbUp",
|
|
"lp_var_sa_lb_down": "salbLow",
|
|
"lp_var_values": "x",
|
|
}.items():
|
|
h5.put_array(
|
|
h5_field,
|
|
np.array(self.inner.getAttr(gp_field, gp_vars), dtype=float),
|
|
)
|
|
|
|
def _extract_after_lp_constrs(self, h5: H5File) -> None:
|
|
def _parse_gurobi_cbasis(v: int) -> str:
|
|
if v == 0:
|
|
return "B"
|
|
if v == -1:
|
|
return "N"
|
|
raise Exception(f"unknown cbasis: {v}")
|
|
|
|
gp_constrs = self.inner.getConstrs()
|
|
h5.put_array(
|
|
"lp_constr_basis_status",
|
|
np.array(
|
|
[
|
|
_parse_gurobi_cbasis(c)
|
|
for c in self.inner.getAttr("cbasis", gp_constrs)
|
|
],
|
|
dtype="S",
|
|
),
|
|
)
|
|
for (h5_field, gp_field) in {
|
|
"lp_constr_dual_values": "pi",
|
|
"lp_constr_sa_rhs_up": "saRhsUp",
|
|
"lp_constr_sa_rhs_down": "saRhsLow",
|
|
}.items():
|
|
h5.put_array(
|
|
h5_field,
|
|
np.array(self.inner.getAttr(gp_field, gp_constrs), dtype=float),
|
|
)
|
|
h5.put_array(
|
|
"lp_constr_slacks",
|
|
np.abs(np.array(self.inner.getAttr("slack", gp_constrs), dtype=float)),
|
|
)
|
|
|
|
def _extract_after_mip_solution_pool(self, h5: H5File) -> None:
|
|
gp_vars = self.inner.getVars()
|
|
pool_var_values = []
|
|
pool_obj_values = []
|
|
for i in range(self.inner.SolCount):
|
|
self.inner.params.SolutionNumber = i
|
|
try:
|
|
pool_var_values.append(self.inner.getAttr("Xn", gp_vars))
|
|
pool_obj_values.append(self.inner.PoolObjVal)
|
|
except GurobiError:
|
|
pass
|
|
h5.put_array("pool_var_values", np.array(pool_var_values))
|
|
h5.put_array("pool_obj_values", np.array(pool_obj_values))
|
|
|
|
def write(self, filename: str) -> None:
|
|
self.inner.update()
|
|
self.inner.write(filename)
|