diff --git a/miplearn/benchmark.py b/miplearn/benchmark.py index f59f759..cfa0501 100644 --- a/miplearn/benchmark.py +++ b/miplearn/benchmark.py @@ -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]) == "": - 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") diff --git a/miplearn/solvers.py b/miplearn/solvers.py index fd44ba9..5ac2db0 100644 --- a/miplearn/solvers.py +++ b/miplearn/solvers.py @@ -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 - - 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 +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"), + } - 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] diff --git a/miplearn/tests/test_solver.py b/miplearn/tests/test_solver.py index df66f7b..7d25431 100644 --- a/miplearn/tests/test_solver.py +++ b/miplearn/tests/test_solver.py @@ -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():