ANL-CEEESA
/
MIPLearn
mirror of https://github.com/ANL-CEEESA/MIPLearn.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Better encapsulate solvers

Browse Source
pull/1/head
Alinson S. Xavier 6 years ago
parent 141c8f0fdf
commit f8e8aeb973
3 changed files with 109 additions and 86 deletions
Show Stats Download Patch File Download Diff File

16
miplearn/benchmark.py
Unescape View File

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

153
miplearn/solvers.py
Unescape View File

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

26
miplearn/tests/test_solver.py
Unescape View File

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

Write Preview
Loading…
Cancel
Save