ANL-CEEESA/MIPLearn
1
0
Fork 0
mirror of https://github.com/ANL-CEEESA/MIPLearn.git synced 2025-12-06 09:28:51 -06:00
Code Issues Packages Projects Releases Wiki Activity

Better encapsulate solvers

Browse Source
This commit is contained in:
Alinson S. Xavier
2020-02-22 20:22:33 -06:00
parent 141c8f0fdf
commit f8e8aeb973
3 changed files with 109 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
miplearn/benchmark.py
View File

@@ -61,25 +61,17 @@ class BenchmarkRunner:
"Nodes",
"Mode",
])
wallclock_time = None
for key in ["Time", "Wall time", "Wallclock time"]:
if key not in result["Solver"][0].keys():
continue
if str(result["Solver"][0][key]) == "<undefined>":
continue
wallclock_time = float(result["Solver"][0][key])
nodes = result["Solver"][0]["Nodes"]
lb = result["Problem"][0]["Lower bound"]
ub = result["Problem"][0]["Upper bound"]
lb = result["Lower bound"]
ub = result["Upper bound"]
gap = (ub - lb) / lb
self.results = self.results.append({
"Solver": name,
"Instance": instance,
"Wallclock Time": wallclock_time,
"Wallclock Time": result["Wallclock time"],
"Lower Bound": lb,
"Upper Bound": ub,
"Gap": gap,
"Nodes": nodes,
"Nodes": result["Nodes"],
"Mode": solver.mode,
}, ignore_index=True)
groups = self.results.groupby("Instance")

153
miplearn/solvers.py
View File

@@ -13,28 +13,55 @@ import logging
logger = logging.getLogger(__name__)
def _solver_factory():
try:
solver = pe.SolverFactory('gurobi_persistent')
assert solver.available()
solver.options["threads"] = 4
solver.options["Seed"] = randint(low=0, high=1000).rvs()
return solver
except Exception as e:
logger.debug(e)
pass
class GurobiSolver:
def __init__(self):
self.solver = pe.SolverFactory('gurobi_persistent')
self.solver.options["Seed"] = randint(low=0, high=1000).rvs()
def set_threads(self, threads):
self.solver.options["Threads"] = threads
def set_time_limit(self, time_limit):
self.solver.options["TimeLimit"] = time_limit
def set_gap_tolerance(self, gap_tolerance):
self.solver.options["MIPGap"] = gap_tolerance
def solve(self, model, tee=False, warmstart=False):
self.solver.set_instance(model)
results = self.solver.solve(tee=tee, warmstart=warmstart)
return {
"Lower bound": results["Problem"][0]["Lower bound"],
"Upper bound": results["Problem"][0]["Upper bound"],
"Wallclock time": results["Solver"][0]["Wallclock time"],
"Nodes": self.solver._solver_model.getAttr("NodeCount"),
}
try:
solver = pe.SolverFactory('cplex_persistent')
assert solver.available()
solver.options["threads"] = 4
solver.options["randomseed"] = randint(low=0, high=1000).rvs()
return solver
except Exception as e:
logger.debug(e)
pass
raise Exception("No solver available")
class CPLEXSolver:
def __init__(self):
self.solver = pe.SolverFactory('cplex_persistent')
self.solver.options["randomseed"] = randint(low=0, high=1000).rvs()
def set_threads(self, threads):
self.solver.options["threads"] = threads
def set_time_limit(self, time_limit):
self.solver.options["timelimit"] = time_limit
def set_gap_tolerance(self, gap_tolerance):
self.solver.options["mip_tolerances_mipgap"] = gap_tolerance
def solve(self, model, tee=False, warmstart=False):
self.solver.set_instance(model)
results = self.solver.solve(tee=tee, warmstart=warmstart)
print(results)
return {
"Lower bound": results["Problem"][0]["Lower bound"],
"Upper bound": results["Problem"][0]["Upper bound"],
"Wallclock time": results["Solver"][0]["Wallclock time"],
"Nodes": 1,
}
class LearningSolver:
@@ -44,21 +71,23 @@ class LearningSolver:
"""
def __init__(self,
threads=None,
time_limit=None,
gap_limit=None,
internal_solver_factory=_solver_factory,
components=None,
mode="exact"):
gap_tolerance=None,
mode="exact",
solver="cplex",
threads=4,
time_limit=None,
):
self.is_persistent = None
self.internal_solver = None
self.components = components
self.internal_solver_factory = internal_solver_factory
self.mode = mode
self.internal_solver = None
self.internal_solver_factory = solver
self.threads = threads
self.time_limit = time_limit
self.gap_limit = gap_limit
self.gap_tolerance = gap_tolerance
self.tee = False
self.mode = mode
if self.components is not None:
assert isinstance(self.components, dict)
@@ -71,23 +100,25 @@ class LearningSolver:
for component in self.components.values():
component.mode = self.mode
def _create_solver(self):
self.internal_solver = self.internal_solver_factory()
self.is_persistent = hasattr(self.internal_solver, "set_instance")
if self.threads is not None:
self.internal_solver.options["Threads"] = self.threads
def _create_internal_solver(self):
if self.internal_solver_factory == "cplex":
solver = CPLEXSolver()
elif self.internal_solver_factory == "gurobi":
solver = GurobiSolver()
else:
raise Exception("solver %s not supported" % solver_factory)
solver.set_threads(self.threads)
if self.time_limit is not None:
self.internal_solver.options["timelimit"] = self.time_limit
if self.gap_limit is not None:
self.internal_solver.options["MIPGap"] = self.gap_limit
solver.set_time_limit(self.time_limit)
if self.gap_tolerance is not None:
solver.set_gap_tolerance(self.gap_tolerance)
return solver
def solve(self, instance, tee=False):
model = instance.to_model()
self.tee = tee
self._create_solver()
if self.is_persistent:
self.internal_solver.set_instance(model)
self.internal_solver = self._create_internal_solver()
for component in self.components.values():
component.before_solve(self, instance, model)
@@ -96,28 +127,24 @@ class LearningSolver:
if "warm-start" in self.components.keys():
if self.components["warm-start"].is_warm_start_available:
is_warm_start_available = True
if self.is_persistent:
solve_results = self.internal_solver.solve(tee=tee, warmstart=is_warm_start_available)
else:
solve_results = self.internal_solver.solve(model, tee=tee, warmstart=is_warm_start_available)
results = self.internal_solver.solve(model,
tee=tee,
warmstart=is_warm_start_available)
instance.solution = {}
instance.lower_bound = solve_results["Problem"][0]["Lower bound"]
instance.upper_bound = solve_results["Problem"][0]["Upper bound"]
instance.lower_bound = results["Lower bound"]
instance.upper_bound = results["Upper bound"]
for var in model.component_objects(Var):
instance.solution[str(var)] = {}
for index in var:
instance.solution[str(var)][index] = var[index].value
if self.internal_solver.name == "gurobi_persistent":
solve_results["Solver"][0]["Nodes"] = self.internal_solver._solver_model.getAttr("NodeCount")
else:
solve_results["Solver"][0]["Nodes"] = 1
for component in self.components.values():
component.after_solve(self, instance, model)
return solve_results
return results
def parallel_solve(self,
instances,
@@ -134,21 +161,21 @@ class LearningSolver:
if not collect_training_data:
solver.components = {}
return {
"solver": solver,
"results": results,
"solution": instance.solution,
"upper bound": instance.upper_bound,
"lower bound": instance.lower_bound,
"Solver": solver,
"Results": results,
"Solution": instance.solution,
"Upper bound": instance.upper_bound,
"Lower bound": instance.lower_bound,
}
p_map_results = p_map(_process, instances, num_cpus=n_jobs, desc=label)
subsolvers = [p["solver"] for p in p_map_results]
results = [p["results"] for p in p_map_results]
subsolvers = [p["Solver"] for p in p_map_results]
results = [p["Results"] for p in p_map_results]
for (idx, r) in enumerate(p_map_results):
instances[idx].solution = r["solution"]
instances[idx].lower_bound = r["lower bound"]
instances[idx].upper_bound = r["upper bound"]
instances[idx].solution = r["Solution"]
instances[idx].lower_bound = r["Lower bound"]
instances[idx].upper_bound = r["Upper bound"]
for (name, component) in self.components.items():
subcomponents = [subsolver.components[name]

26
miplearn/tests/test_solver.py
View File

@@ -16,17 +16,21 @@ def _get_instance():
def test_solver():
instance = _get_instance()
solver = LearningSolver()
solver.solve(instance)
assert instance.solution["x"][0] == 1.0
assert instance.solution["x"][1] == 0.0
assert instance.solution["x"][2] == 1.0
assert instance.solution["x"][3] == 1.0
assert instance.lower_bound == 1183.0
assert instance.upper_bound == 1183.0
solver.fit()
solver.solve(instance)
for internal_solver in ["cplex", "gurobi"]:
solver = LearningSolver(time_limit=300,
gap_tolerance=1e-3,
threads=1,
solver=internal_solver,
)
results = solver.solve(instance)
assert instance.solution["x"][0] == 1.0
assert instance.solution["x"][1] == 0.0
assert instance.solution["x"][2] == 1.0
assert instance.solution["x"][3] == 1.0
assert instance.lower_bound == 1183.0
assert instance.upper_bound == 1183.0
solver.fit()
solver.solve(instance)
def test_solve_save_load_state():