Move tests to separate folder

tests/solvers/__init__.py

@@ -0,0 +1,70 @@
+#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
+#  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
+#  Released under the modified BSD license. See COPYING.md for more details.
+
+from inspect import isclass
+from typing import List, Callable, Any
+
+from pyomo import environ as pe
+
+from miplearn.instance import Instance
+from miplearn.problems.knapsack import KnapsackInstance, GurobiKnapsackInstance
+from miplearn.solvers.gurobi import GurobiSolver
+from miplearn.solvers.internal import InternalSolver
+from miplearn.solvers.pyomo.base import BasePyomoSolver
+from miplearn.solvers.pyomo.gurobi import GurobiPyomoSolver
+from miplearn.solvers.pyomo.xpress import XpressPyomoSolver
+
+
+class InfeasiblePyomoInstance(Instance):
+    def to_model(self) -> pe.ConcreteModel:
+        model = pe.ConcreteModel()
+        model.x = pe.Var([0], domain=pe.Binary)
+        model.OBJ = pe.Objective(expr=model.x[0], sense=pe.maximize)
+        model.eq = pe.Constraint(expr=model.x[0] >= 2)
+        return model
+
+
+class InfeasibleGurobiInstance(Instance):
+    def to_model(self) -> Any:
+        import gurobipy as gp
+        from gurobipy import GRB
+
+        model = gp.Model()
+        x = model.addVars(1, vtype=GRB.BINARY, name="x")
+        model.addConstr(x[0] >= 2)
+        model.setObjective(x[0])
+        return model
+
+
+def _is_subclass_or_instance(obj, parent_class):
+    return isinstance(obj, parent_class) or (
+        isclass(obj) and issubclass(obj, parent_class)
+    )
+
+
+def _get_knapsack_instance(solver):
+    if _is_subclass_or_instance(solver, BasePyomoSolver):
+        return KnapsackInstance(
+            weights=[23.0, 26.0, 20.0, 18.0],
+            prices=[505.0, 352.0, 458.0, 220.0],
+            capacity=67.0,
+        )
+    if _is_subclass_or_instance(solver, GurobiSolver):
+        return GurobiKnapsackInstance(
+            weights=[23.0, 26.0, 20.0, 18.0],
+            prices=[505.0, 352.0, 458.0, 220.0],
+            capacity=67.0,
+        )
+    assert False
+
+
+def _get_infeasible_instance(solver):
+    if _is_subclass_or_instance(solver, BasePyomoSolver):
+        return InfeasiblePyomoInstance()
+    if _is_subclass_or_instance(solver, GurobiSolver):
+        return InfeasibleGurobiInstance()
+
+
+def _get_internal_solvers() -> List[Callable[[], InternalSolver]]:
+    return [GurobiPyomoSolver, GurobiSolver, XpressPyomoSolver]

tests/solvers/test_internal_solver.py

@@ -0,0 +1,219 @@
+#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
+#  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
+#  Released under the modified BSD license. See COPYING.md for more details.
+
+import logging
+from io import StringIO
+from warnings import warn
+
+import pyomo.environ as pe
+
+from miplearn.solvers import _RedirectOutput
+from miplearn.solvers.gurobi import GurobiSolver
+from miplearn.solvers.pyomo.base import BasePyomoSolver
+from . import (
+    _get_knapsack_instance,
+    _get_internal_solvers,
+    _get_infeasible_instance,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def test_redirect_output():
+    import sys
+
+    original_stdout = sys.stdout
+    io = StringIO()
+    with _RedirectOutput([io]):
+        print("Hello world")
+    assert sys.stdout == original_stdout
+    assert io.getvalue() == "Hello world\n"
+
+
+def test_internal_solver_warm_starts():
+    for solver_class in _get_internal_solvers():
+        logger.info("Solver: %s" % solver_class)
+        instance = _get_knapsack_instance(solver_class)
+        model = instance.to_model()
+        solver = solver_class()
+        solver.set_instance(instance, model)
+        solver.set_warm_start(
+            {
+                "x": {
+                    0: 1.0,
+                    1: 0.0,
+                    2: 0.0,
+                    3: 1.0,
+                }
+            }
+        )
+        stats = solver.solve(tee=True)
+        if stats["Warm start value"] is not None:
+            assert stats["Warm start value"] == 725.0
+        else:
+            warn(f"{solver_class.__name__} should set warm start value")
+
+        solver.set_warm_start(
+            {
+                "x": {
+                    0: 1.0,
+                    1: 1.0,
+                    2: 1.0,
+                    3: 1.0,
+                }
+            }
+        )
+        stats = solver.solve(tee=True)
+        assert stats["Warm start value"] is None
+
+        solver.fix(
+            {
+                "x": {
+                    0: 1.0,
+                    1: 0.0,
+                    2: 0.0,
+                    3: 1.0,
+                }
+            }
+        )
+        stats = solver.solve(tee=True)
+        assert stats["Lower bound"] == 725.0
+        assert stats["Upper bound"] == 725.0
+
+
+def test_internal_solver():
+    for solver_class in _get_internal_solvers():
+        logger.info("Solver: %s" % solver_class)
+
+        instance = _get_knapsack_instance(solver_class)
+        model = instance.to_model()
+        solver = solver_class()
+        solver.set_instance(instance, model)
+
+        stats = solver.solve_lp()
+        assert not solver.is_infeasible()
+        assert round(stats["Optimal value"], 3) == 1287.923
+        assert len(stats["Log"]) > 100
+
+        solution = solver.get_solution()
+        assert round(solution["x"][0], 3) == 1.000
+        assert round(solution["x"][1], 3) == 0.923
+        assert round(solution["x"][2], 3) == 1.000
+        assert round(solution["x"][3], 3) == 0.000
+
+        stats = solver.solve(tee=True)
+        assert not solver.is_infeasible()
+        assert len(stats["Log"]) > 100
+        assert stats["Lower bound"] == 1183.0
+        assert stats["Upper bound"] == 1183.0
+        assert stats["Sense"] == "max"
+        assert isinstance(stats["Wallclock time"], float)
+
+        solution = solver.get_solution()
+        assert solution["x"][0] == 1.0
+        assert solution["x"][1] == 0.0
+        assert solution["x"][2] == 1.0
+        assert solution["x"][3] == 1.0
+
+        # Add a brand new constraint
+        if isinstance(solver, BasePyomoSolver):
+            model.cut = pe.Constraint(expr=model.x[0] <= 0.0, name="cut")
+            solver.add_constraint(model.cut)
+        elif isinstance(solver, GurobiSolver):
+            x = model.getVarByName("x[0]")
+            solver.add_constraint(x <= 0.0, name="cut")
+        else:
+            raise Exception("Illegal state")
+
+        # New constraint should affect solution and should be listed in
+        # constraint ids
+        assert solver.get_constraint_ids() == ["eq_capacity", "cut"]
+        stats = solver.solve()
+        assert stats["Lower bound"] == 1030.0
+
+        assert solver.get_sense() == "max"
+        assert solver.get_constraint_sense("cut") == "<"
+        assert solver.get_constraint_sense("eq_capacity") == "<"
+
+        # Verify slacks
+        assert solver.get_inequality_slacks() == {
+            "cut": 0.0,
+            "eq_capacity": 3.0,
+        }
+
+        if isinstance(solver, GurobiSolver):
+            # Extract the new constraint
+            cobj = solver.extract_constraint("cut")
+
+            # New constraint should no longer affect solution and should no longer
+            # be listed in constraint ids
+            assert solver.get_constraint_ids() == ["eq_capacity"]
+            stats = solver.solve()
+            assert stats["Lower bound"] == 1183.0
+
+            # New constraint should not be satisfied by current solution
+            assert not solver.is_constraint_satisfied(cobj)
+
+            # Re-add constraint
+            solver.add_constraint(cobj)
+
+            # Constraint should affect solution again
+            assert solver.get_constraint_ids() == ["eq_capacity", "cut"]
+            stats = solver.solve()
+            assert stats["Lower bound"] == 1030.0
+
+            # New constraint should now be satisfied
+            assert solver.is_constraint_satisfied(cobj)
+
+            # Relax problem and make cut into an equality constraint
+            solver.relax()
+            solver.set_constraint_sense("cut", "=")
+            stats = solver.solve()
+            assert round(stats["Lower bound"]) == 1030.0
+            assert round(solver.get_dual("eq_capacity")) == 0.0
+
+
+def test_relax():
+    for solver_class in _get_internal_solvers():
+        instance = _get_knapsack_instance(solver_class)
+        solver = solver_class()
+        solver.set_instance(instance)
+        solver.relax()
+        stats = solver.solve()
+        assert round(stats["Lower bound"]) == 1288.0
+
+
+def test_infeasible_instance():
+    for solver_class in _get_internal_solvers():
+        instance = _get_infeasible_instance(solver_class)
+        solver = solver_class()
+        solver.set_instance(instance)
+        stats = solver.solve()
+
+        assert solver.is_infeasible()
+        assert solver.get_solution() is None
+        assert stats["Upper bound"] is None
+        assert stats["Lower bound"] is None
+
+        stats = solver.solve_lp()
+        assert solver.get_solution() is None
+        assert stats["Optimal value"] is None
+        assert solver.get_value("x", 0) is None
+
+
+def test_iteration_cb():
+    for solver_class in _get_internal_solvers():
+        logger.info("Solver: %s" % solver_class)
+        instance = _get_knapsack_instance(solver_class)
+        solver = solver_class()
+        solver.set_instance(instance)
+        count = 0
+
+        def custom_iteration_cb():
+            nonlocal count
+            count += 1
+            return count < 5
+
+        solver.solve(iteration_cb=custom_iteration_cb)
+        assert count == 5

tests/solvers/test_lazy_cb.py

@@ -0,0 +1,27 @@
+#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
+#  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
+#  Released under the modified BSD license. See COPYING.md for more details.
+
+import logging
+
+from miplearn.solvers.gurobi import GurobiSolver
+from . import _get_knapsack_instance
+
+logger = logging.getLogger(__name__)
+
+
+def test_lazy_cb():
+    solver = GurobiSolver()
+    instance = _get_knapsack_instance(solver)
+    model = instance.to_model()
+
+    def lazy_cb(cb_solver, cb_model):
+        logger.info("x[0] = %.f" % cb_solver.get_value("x", 0))
+        cobj = (cb_model.getVarByName("x[0]") * 1.0, "<", 0.0, "cut")
+        if not cb_solver.is_constraint_satisfied(cobj):
+            cb_solver.add_constraint(cobj)
+
+    solver.set_instance(instance, model)
+    solver.solve(lazy_cb=lazy_cb)
+    solution = solver.get_solution()
+    assert solution["x"][0] == 0.0

tests/solvers/test_learning_solver.py

@@ -0,0 +1,142 @@
+#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
+#  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
+#  Released under the modified BSD license. See COPYING.md for more details.
+
+import logging
+import pickle
+import tempfile
+import os
+
+from miplearn.solvers.gurobi import GurobiSolver
+from miplearn.solvers.learning import LearningSolver
+from . import _get_knapsack_instance, _get_internal_solvers
+
+logger = logging.getLogger(__name__)
+
+
+def test_learning_solver():
+    for mode in ["exact", "heuristic"]:
+        for internal_solver in _get_internal_solvers():
+            logger.info("Solver: %s" % internal_solver)
+            instance = _get_knapsack_instance(internal_solver)
+            solver = LearningSolver(
+                solver=internal_solver,
+                mode=mode,
+            )
+
+            solver.solve(instance)
+            data = instance.training_data[0]
+            assert data["Solution"]["x"][0] == 1.0
+            assert data["Solution"]["x"][1] == 0.0
+            assert data["Solution"]["x"][2] == 1.0
+            assert data["Solution"]["x"][3] == 1.0
+            assert data["Lower bound"] == 1183.0
+            assert data["Upper bound"] == 1183.0
+            assert round(data["LP solution"]["x"][0], 3) == 1.000
+            assert round(data["LP solution"]["x"][1], 3) == 0.923
+            assert round(data["LP solution"]["x"][2], 3) == 1.000
+            assert round(data["LP solution"]["x"][3], 3) == 0.000
+            assert round(data["LP value"], 3) == 1287.923
+            assert len(data["MIP log"]) > 100
+
+            solver.fit([instance])
+            solver.solve(instance)
+
+            # Assert solver is picklable
+            with tempfile.TemporaryFile() as file:
+                pickle.dump(solver, file)
+
+
+def test_solve_without_lp():
+    for internal_solver in _get_internal_solvers():
+        logger.info("Solver: %s" % internal_solver)
+        instance = _get_knapsack_instance(internal_solver)
+        solver = LearningSolver(
+            solver=internal_solver,
+            solve_lp_first=False,
+        )
+        solver.solve(instance)
+        solver.fit([instance])
+        solver.solve(instance)
+
+
+def test_parallel_solve():
+    for internal_solver in _get_internal_solvers():
+        instances = [_get_knapsack_instance(internal_solver) for _ in range(10)]
+        solver = LearningSolver(solver=internal_solver)
+        results = solver.parallel_solve(instances, n_jobs=3)
+        assert len(results) == 10
+        for instance in instances:
+            data = instance.training_data[0]
+            assert len(data["Solution"]["x"].keys()) == 4
+
+
+def test_solve_fit_from_disk():
+    for internal_solver in _get_internal_solvers():
+        # Create instances and pickle them
+        filenames = []
+        for k in range(3):
+            instance = _get_knapsack_instance(internal_solver)
+            with tempfile.NamedTemporaryFile(suffix=".pkl", delete=False) as file:
+                filenames += [file.name]
+                pickle.dump(instance, file)
+
+        # Test: solve
+        solver = LearningSolver(solver=internal_solver)
+        solver.solve(filenames[0])
+        with open(filenames[0], "rb") as file:
+            instance = pickle.load(file)
+            assert len(instance.training_data) > 0
+
+        # Test: parallel_solve
+        solver.parallel_solve(filenames)
+        for filename in filenames:
+            with open(filename, "rb") as file:
+                instance = pickle.load(file)
+                assert len(instance.training_data) > 0
+
+        # Test: solve (with specified output)
+        output = [f + ".out" for f in filenames]
+        solver.solve(
+            filenames[0],
+            output_filename=output[0],
+        )
+        assert os.path.isfile(output[0])
+
+        # Test: parallel_solve (with specified output)
+        solver.parallel_solve(
+            filenames,
+            output_filenames=output,
+        )
+        for filename in output:
+            assert os.path.isfile(filename)
+
+        # Delete temporary files
+        for filename in filenames:
+            os.remove(filename)
+        for filename in output:
+            os.remove(filename)
+
+
+def test_simulate_perfect():
+    internal_solver = GurobiSolver
+    instance = _get_knapsack_instance(internal_solver)
+    with tempfile.NamedTemporaryFile(suffix=".pkl", delete=False) as tmp:
+        pickle.dump(instance, tmp)
+        tmp.flush()
+        solver = LearningSolver(
+            solver=internal_solver,
+            simulate_perfect=True,
+        )
+        stats = solver.solve(tmp.name)
+        assert stats["Lower bound"] == stats["Predicted LB"]
+
+
+def test_gap():
+    assert LearningSolver._compute_gap(ub=0.0, lb=0.0) == 0.0
+    assert LearningSolver._compute_gap(ub=1.0, lb=0.5) == 0.5
+    assert LearningSolver._compute_gap(ub=1.0, lb=1.0) == 0.0
+    assert LearningSolver._compute_gap(ub=1.0, lb=-1.0) is None
+    assert LearningSolver._compute_gap(ub=1.0, lb=None) is None
+    assert LearningSolver._compute_gap(ub=None, lb=1.0) is None
+    assert LearningSolver._compute_gap(ub=None, lb=None) is None