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

Use np.ndarray in Variables

Browse Source
This commit is contained in:
Alinson S. Xavier
2021-08-05 15:42:19 -05:00
parent b6426462a1
commit 0c4b0ea81a
10 changed files with 110 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
miplearn/solvers/__init__.py
View File

@@ -4,7 +4,7 @@
import logging
import sys
from typing import Any, List, TextIO, cast
from typing import Any, List, TextIO, cast, TypeVar, Optional, Sized
logger = logging.getLogger(__name__)
@@ -38,7 +38,10 @@ class _RedirectOutput:
sys.stderr = self._original_stderr
def _none_if_empty(obj: Any) -> Any:
T = TypeVar("T", bound=Sized)
def _none_if_empty(obj: T) -> Optional[T]:
if len(obj) == 0:
return None
else:

56
miplearn/solvers/gurobi.py
View File

@@ -6,8 +6,9 @@ import re
import sys
from io import StringIO
from random import randint
from typing import List, Any, Dict, Optional, Tuple, TYPE_CHECKING
from typing import List, Any, Dict, Optional, TYPE_CHECKING
import numpy as np
from overrides import overrides
from miplearn.instance.base import Instance
@@ -79,9 +80,9 @@ class GurobiSolver(InternalSolver):
self._var_names: List[str] = []
self._constr_names: List[str] = []
self._var_types: List[str] = []
self._var_lbs: List[float] = []
self._var_ubs: List[float] = []
self._var_obj_coeffs: List[float] = []
self._var_lbs: np.ndarray = np.empty(0)
self._var_ubs: np.ndarray = np.empty(0)
self._var_obj_coeffs: np.ndarray = np.empty(0)
if self.lazy_cb_frequency == 1:
self.lazy_cb_where = [self.gp.GRB.Callback.MIPSOL]
@@ -338,15 +339,33 @@ class GurobiSolver(InternalSolver):
)
if with_sa:
sa_obj_up = model.getAttr("saobjUp", self._gp_vars)
sa_obj_down = model.getAttr("saobjLow", self._gp_vars)
sa_ub_up = model.getAttr("saubUp", self._gp_vars)
sa_ub_down = model.getAttr("saubLow", self._gp_vars)
sa_lb_up = model.getAttr("salbUp", self._gp_vars)
sa_lb_down = model.getAttr("salbLow", self._gp_vars)
sa_obj_up = np.array(
model.getAttr("saobjUp", self._gp_vars),
dtype=float,
)
sa_obj_down = np.array(
model.getAttr("saobjLow", self._gp_vars),
dtype=float,
)
sa_ub_up = np.array(
model.getAttr("saubUp", self._gp_vars),
dtype=float,
)
sa_ub_down = np.array(
model.getAttr("saubLow", self._gp_vars),
dtype=float,
)
sa_lb_up = np.array(
model.getAttr("salbUp", self._gp_vars),
dtype=float,
)
sa_lb_down = np.array(
model.getAttr("salbLow", self._gp_vars),
dtype=float,
)
if model.solCount > 0:
values = model.getAttr("x", self._gp_vars)
values = np.array(model.getAttr("x", self._gp_vars), dtype=float)
return Variables(
names=self._var_names,
@@ -565,9 +584,18 @@ class GurobiSolver(InternalSolver):
gp_constrs: List["gurobipy.Constr"] = self.model.getConstrs()
var_names: List[str] = self.model.getAttr("varName", gp_vars)
var_types: List[str] = self.model.getAttr("vtype", gp_vars)
var_ubs: List[float] = self.model.getAttr("ub", gp_vars)
var_lbs: List[float] = self.model.getAttr("lb", gp_vars)
var_obj_coeffs: List[float] = self.model.getAttr("obj", gp_vars)
var_ubs: np.ndarray = np.array(
self.model.getAttr("ub", gp_vars),
dtype=float,
)
var_lbs: np.ndarray = np.array(
self.model.getAttr("lb", gp_vars),
dtype=float,
)
var_obj_coeffs: np.ndarray = np.array(
self.model.getAttr("obj", gp_vars),
dtype=float,
)
constr_names: List[str] = self.model.getAttr("constrName", gp_constrs)
varname_to_var: Dict = {}
cname_to_constr: Dict = {}

24
miplearn/solvers/internal.py
View File

@@ -7,6 +7,8 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Any, Optional, List, Tuple, TYPE_CHECKING
import numpy as np
from miplearn.instance.base import Instance
from miplearn.types import (
IterationCallback,
@@ -50,18 +52,18 @@ class MIPSolveStats:
class Variables:
names: Optional[List[str]] = None
basis_status: Optional[List[str]] = None
lower_bounds: Optional[List[float]] = None
obj_coeffs: Optional[List[float]] = None
reduced_costs: Optional[List[float]] = None
sa_lb_down: Optional[List[float]] = None
sa_lb_up: Optional[List[float]] = None
sa_obj_down: Optional[List[float]] = None
sa_obj_up: Optional[List[float]] = None
sa_ub_down: Optional[List[float]] = None
sa_ub_up: Optional[List[float]] = None
lower_bounds: Optional[np.ndarray] = None
obj_coeffs: Optional[np.ndarray] = None
reduced_costs: Optional[np.ndarray] = None
sa_lb_down: Optional[np.ndarray] = None
sa_lb_up: Optional[np.ndarray] = None
sa_obj_down: Optional[np.ndarray] = None
sa_obj_up: Optional[np.ndarray] = None
sa_ub_down: Optional[np.ndarray] = None
sa_ub_up: Optional[np.ndarray] = None
types: Optional[List[str]] = None
upper_bounds: Optional[List[float]] = None
values: Optional[List[float]] = None
upper_bounds: Optional[np.ndarray] = None
values: Optional[np.ndarray] = None
@dataclass

10
miplearn/solvers/pyomo/base.py
View File

@@ -330,11 +330,11 @@ class BasePyomoSolver(InternalSolver):
return Variables(
names=_none_if_empty(names),
types=_none_if_empty(types),
upper_bounds=_none_if_empty(upper_bounds),
lower_bounds=_none_if_empty(lower_bounds),
obj_coeffs=_none_if_empty(obj_coeffs),
reduced_costs=_none_if_empty(reduced_costs),
values=_none_if_empty(values),
upper_bounds=_none_if_empty(np.array(upper_bounds, dtype=float)),
lower_bounds=_none_if_empty(np.array(lower_bounds, dtype=float)),
obj_coeffs=_none_if_empty(np.array(obj_coeffs, dtype=float)),
reduced_costs=_none_if_empty(np.array(reduced_costs, dtype=float)),
values=_none_if_empty(np.array(values, dtype=float)),
)
@overrides

28
miplearn/solvers/tests/__init__.py
View File

@@ -41,10 +41,10 @@ def run_basic_usage_tests(solver: InternalSolver) -> None:
solver.get_variables(),
Variables(
names=["x[0]", "x[1]", "x[2]", "x[3]", "z"],
lower_bounds=[0.0, 0.0, 0.0, 0.0, 0.0],
upper_bounds=[1.0, 1.0, 1.0, 1.0, 67.0],
lower_bounds=np.array([0.0, 0.0, 0.0, 0.0, 0.0]),
upper_bounds=np.array([1.0, 1.0, 1.0, 1.0, 67.0]),
types=["B", "B", "B", "B", "C"],
obj_coeffs=[505.0, 352.0, 458.0, 220.0, 0.0],
obj_coeffs=np.array([505.0, 352.0, 458.0, 220.0, 0.0]),
),
)
@@ -85,14 +85,18 @@ def run_basic_usage_tests(solver: InternalSolver) -> None:
Variables(
names=["x[0]", "x[1]", "x[2]", "x[3]", "z"],
basis_status=["U", "B", "U", "L", "U"],
reduced_costs=[193.615385, 0.0, 187.230769, -23.692308, 13.538462],
sa_lb_down=[-inf, -inf, -inf, -0.111111, -inf],
sa_lb_up=[1.0, 0.923077, 1.0, 1.0, 67.0],
sa_obj_down=[311.384615, 317.777778, 270.769231, -inf, -13.538462],
sa_obj_up=[inf, 570.869565, inf, 243.692308, inf],
sa_ub_down=[0.913043, 0.923077, 0.9, 0.0, 43.0],
sa_ub_up=[2.043478, inf, 2.2, inf, 69.0],
values=[1.0, 0.923077, 1.0, 0.0, 67.0],
reduced_costs=np.array(
[193.615385, 0.0, 187.230769, -23.692308, 13.538462]
),
sa_lb_down=np.array([-inf, -inf, -inf, -0.111111, -inf]),
sa_lb_up=np.array([1.0, 0.923077, 1.0, 1.0, 67.0]),
sa_obj_down=np.array(
[311.384615, 317.777778, 270.769231, -inf, -13.538462]
),
sa_obj_up=np.array([inf, 570.869565, inf, 243.692308, inf]),
sa_ub_down=np.array([0.913043, 0.923077, 0.9, 0.0, 43.0]),
sa_ub_up=np.array([2.043478, inf, 2.2, inf, 69.0]),
values=np.array([1.0, 0.923077, 1.0, 0.0, 67.0]),
),
),
)
@@ -137,7 +141,7 @@ def run_basic_usage_tests(solver: InternalSolver) -> None:
solver.get_variable_attrs(),
Variables(
names=["x[0]", "x[1]", "x[2]", "x[3]", "z"],
values=[1.0, 0.0, 1.0, 1.0, 61.0],
values=np.array([1.0, 0.0, 1.0, 1.0, 61.0]),
),
),
)