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

Remove sample.after_lp

Browse Source
This commit is contained in:
Alinson S. Xavier
2021-07-01 12:25:50 -05:00
parent 4093ac62fd
commit b4a267a524
8 changed files with 95 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
miplearn/components/objective.py
View File

@@ -77,20 +77,15 @@ class ObjectiveValueComponent(Component):
_: Optional[Instance],
sample: Sample,
) -> Tuple[Dict[Hashable, List[List[float]]], Dict[Hashable, List[List[float]]]]:
# Instance features
assert sample.after_load is not None
assert sample.after_load.instance is not None
f = sample.after_load.instance.to_list()
# LP solve features
if sample.after_lp is not None:
assert sample.after_lp.lp_solve is not None
f.extend(sample.after_lp.lp_solve.to_list())
lp_instance_features = sample.get("lp_instance_features")
if lp_instance_features is None:
lp_instance_features = sample.get("instance_features_user")
assert lp_instance_features is not None
# Features
x: Dict[Hashable, List[List[float]]] = {
"Upper bound": [f],
"Lower bound": [f],
"Upper bound": [lp_instance_features],
"Lower bound": [lp_instance_features],
}
# Labels

15
miplearn/components/primal.py
View File

@@ -155,7 +155,15 @@ class PrimalSolutionComponent(Component):
assert sample.after_load.variables is not None
assert sample.after_load.variables.names is not None
assert sample.after_load.variables.categories is not None
instance_features = sample.get("instance_features_user")
mip_var_values = sample.get("mip_var_values")
var_features = sample.get("lp_var_features")
if var_features is None:
var_features = sample.get("var_features")
assert instance_features is not None
assert var_features is not None
for (i, var_name) in enumerate(sample.after_load.variables.names):
# Initialize categories
@@ -167,11 +175,8 @@ class PrimalSolutionComponent(Component):
y[category] = []
# Features
features = list(sample.after_load.instance.to_list())
features.extend(sample.after_load.variables.to_list(i))
if sample.after_lp is not None:
assert sample.after_lp.variables is not None
features.extend(sample.after_lp.variables.to_list(i))
features = list(instance_features)
features.extend(var_features[i])
x[category].append(features)
# Labels

37
miplearn/components/static_lazy.py
View File

@@ -204,17 +204,26 @@ class StaticLazyConstraintsComponent(Component):
x: Dict[Hashable, List[List[float]]] = {}
y: Dict[Hashable, List[List[float]]] = {}
cids: Dict[Hashable, List[str]] = {}
assert sample.after_load is not None
constraints = sample.after_load.constraints
assert constraints is not None
assert constraints.names is not None
assert constraints.lazy is not None
assert constraints.categories is not None
for (cidx, cname) in enumerate(constraints.names):
instance_features = sample.get("instance_features_user")
constr_features = sample.get("lp_constr_features")
constr_names = sample.get("constr_names")
constr_categories = sample.get("constr_categories")
constr_lazy = sample.get("constr_lazy")
lazy_enforced = sample.get("lazy_enforced")
if constr_features is None:
constr_features = sample.get("constr_features_user")
assert instance_features is not None
assert constr_features is not None
assert constr_names is not None
assert constr_categories is not None
assert constr_lazy is not None
for (cidx, cname) in enumerate(constr_names):
# Initialize categories
if not constraints.lazy[cidx]:
if not constr_lazy[cidx]:
continue
category = constraints.categories[cidx]
category = constr_categories[cidx]
if category is None:
continue
if category not in x:
@@ -223,18 +232,12 @@ class StaticLazyConstraintsComponent(Component):
cids[category] = []
# Features
sf = sample.after_load
if sample.after_lp is not None:
sf = sample.after_lp
assert sf.instance is not None
assert sf.constraints is not None
features = list(sf.instance.to_list())
features.extend(sf.constraints.to_list(cidx))
features = list(instance_features)
features.extend(constr_features[cidx])
x[category].append(features)
cids[category].append(cname)
# Labels
lazy_enforced = sample.get("lazy_enforced")
if lazy_enforced is not None:
if cname in lazy_enforced:
y[category] += [[False, True]]

25
miplearn/features.py
View File

@@ -147,14 +147,12 @@ class Sample:
def __init__(
self,
after_load: Optional[Features] = None,
after_lp: Optional[Features] = None,
data: Optional[Dict[str, Any]] = None,
) -> None:
if data is None:
data = {}
self._data: Dict[str, Any] = data
self.after_load = after_load
self.after_lp = after_lp
def get(self, key: str) -> Optional[Any]:
if key in self._data:
@@ -253,6 +251,29 @@ class FeaturesExtractor:
],
),
)
sample.put(
"lp_constr_features",
self._combine(
sample,
[
"constr_features_user",
"lp_constr_dual_values",
"lp_constr_sa_rhs_down",
"lp_constr_sa_rhs_up",
"lp_constr_slacks",
],
),
)
instance_features_user = sample.get("instance_features_user")
assert instance_features_user is not None
sample.put(
"lp_instance_features",
instance_features_user
+ [
sample.get("lp_value"),
sample.get("lp_wallclock_time"),
],
)
def extract_after_mip_features(
self,

13
miplearn/solvers/learning.py
View File

@@ -210,20 +210,13 @@ class LearningSolver:
# -------------------------------------------------------
logger.info("Extracting features (after-lp)...")
initial_time = time.time()
for (k, v) in lp_stats.__dict__.items():
sample.put(k, v)
self.extractor.extract_after_lp_features(self.internal_solver, sample)
features = self.extractor.extract(
instance,
self.internal_solver,
with_static=False,
)
logger.info(
"Features (after-lp) extracted in %.2f seconds"
% (time.time() - initial_time)
)
for (k, v) in lp_stats.__dict__.items():
sample.put(k, v)
features.lp_solve = lp_stats
sample.after_lp = features
# Callback wrappers
# -------------------------------------------------------
@@ -285,9 +278,9 @@ class LearningSolver:
# -------------------------------------------------------
logger.info("Extracting features (after-mip)...")
initial_time = time.time()
self.extractor.extract_after_mip_features(self.internal_solver, sample)
for (k, v) in mip_stats.__dict__.items():
sample.put(k, v)
self.extractor.extract_after_mip_features(self.internal_solver, sample)
logger.info(
"Features (after-mip) extracted in %.2f seconds"
% (time.time() - initial_time)