Better encapsulate solvers

miplearn/benchmark.py

@@ -61,25 +61,17 @@ class BenchmarkRunner:
                                                  "Nodes",
                                                  "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
         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")

miplearn/solvers.py

@@ -13,28 +13,55 @@ import logging
 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()
-        return solver
-    except Exception as e:
-        logger.debug(e)
-        pass
     
-    try:
+    def set_threads(self, threads):
-        solver = pe.SolverFactory('cplex_persistent')
+        self.solver.options["Threads"] = threads
-        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")
+    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"),
+        }    
+
+    
+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):
+    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:
-            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):
         model = instance.to_model()
         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():
             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)
+        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.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):
             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,
+                "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)
-        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):
-            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():
             subcomponents = [subsolver.components[name]

miplearn/tests/test_solver.py

@@ -16,15 +16,19 @@ def _get_instance():
 
 def test_solver():
     instance = _get_instance()
-    solver = LearningSolver()
+    for internal_solver in ["cplex", "gurobi"]:
-    solver.solve(instance)
+        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)