def _get_constraint_exprs(constraints, hull_to_bigm_map):
"""Returns a list of expressions which are constrain.expr translated
into the bigm space, for each constraint in constraints.
"""
cuts = []
for cons in constraints:
cuts.append(clone_without_expression_components(
cons.expr, substitute=hull_to_bigm_map))
return cuts
def test_clone_without_expression_components(self):
m = ConcreteModel()
m.x = Var(initialize=5)
m.y = Var(initialize=3)
m.e = Expression(expr=m.x**2 + m.x - 1)
base = m.x**2 + 1
test = clone_without_expression_components(base, {})
self.assertIs(base, test)
self.assertEqual(base(), test())
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2 + 1, test())
base = m.e
test = clone_without_expression_components(base, {})
self.assertIsNot(base, test)
self.assertEqual(base(), test())
self.assertIsInstance(base, _ExpressionData)
self.assertIsInstance(test, EXPR.SumExpression)
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2 + 3 - 1, test())
base = m.e + m.x
test = clone_without_expression_components(base, {})
self.assertIsNot(base, test)
self.assertEqual(base(), test())
self.assertIsInstance(base, EXPR.SumExpression)
self.assertIsInstance(test, EXPR.SumExpression)
self.assertIsInstance(base.arg(0), _ExpressionData)
self.assertIsInstance(test.arg(0), EXPR.SumExpression)
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2 + 3 - 1 + 3, test())
def test_clone_without_expression_components(self):
m = ConcreteModel()
m.x = Var(initialize=5)
m.y = Var(initialize=3)
m.e = Expression(expr=m.x**2 + m.x - 1)
base = m.x**2 + 1
test = clone_without_expression_components(base, {})
self.assertIs(base, test)
self.assertEqual(base(), test())
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2+1, test())
base = m.e
test = clone_without_expression_components(base, {})
self.assertIsNot(base, test)
self.assertEqual(base(), test())
self.assertIsInstance(base, _ExpressionData)
self.assertIsInstance(test, EXPR.SumExpression)
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2+3-1, test())
base = m.e + m.x
test = clone_without_expression_components(base, {})
self.assertIsNot(base, test)
self.assertEqual(base(), test())
self.assertIsInstance(base, EXPR.SumExpression)
self.assertIsInstance(test, EXPR.SumExpression)
self.assertIsInstance(base.arg(0), _ExpressionData)
self.assertIsInstance(test.arg(0), EXPR.SumExpression)
test = clone_without_expression_components(base, {id(m.x): m.y})
self.assertEqual(3**2+3-1 + 3, test())
def back_off_constraint_with_calculated_cut_violation(cut, transBlock_rHull,
bigm_to_hull_map, opt,
stream_solver, TOL):
"""Calculates the maximum violation of cut subject to the relaxed hull
constraints. Increases this violation by TOL (to account for optimality
tolerance in solving the problem), and, if it finds that cut can be violated
up to this tolerance, makes it more conservative such that it no longer can.
Parameters
----------
cut: The cut to be made more conservative, a Constraint
transBlock_rHull: the relaxed hull model's transformation Block
bigm_to_hull_map: Dictionary mapping ids of bigM variables to the
corresponding variables on the relaxed hull instance
opt: SolverFactory object for solving the maximum violation problem
stream_solver: Whether or not to set tee=True while solving the maximum
violation problem.
TOL: An absolute tolerance to be added to the calculated cut violation,
to account for optimality tolerance in the maximum violation problem
solve.
"""
instance_rHull = transBlock_rHull.model()
logger.info("Post-processing cut: %s" % cut.expr)
# Take a constraint. We will solve a problem maximizing its violation
# subject to rHull. We will add some user-specified tolerance to that
# violation, and then add that much padding to it if it can be violated.
transBlock_rHull.separation_objective.deactivate()
transBlock_rHull.infeasibility_objective = Objective(
expr=clone_without_expression_components(cut.body,
substitute=bigm_to_hull_map))
results = opt.solve(instance_rHull, tee=stream_solver)
if verify_successful_solve(results) is not NORMAL:
logger.warning("Problem to determine how much to "
"back off the new cut "
"did not solve normally. Leaving the constraint as is, "
"which could lead to numerical trouble%s" % (results,))
# restore the objective
transBlock_rHull.del_component(transBlock_rHull.infeasibility_objective)
transBlock_rHull.separation_objective.activate()
return
# we're minimizing, val is <= 0
val = value(transBlock_rHull.infeasibility_objective) - TOL
if val <= 0:
logger.info("\tBacking off cut by %s" % val)
cut._body += abs(val)
# else there is nothing to do: restore the objective
transBlock_rHull.del_component(transBlock_rHull.infeasibility_objective)
transBlock_rHull.separation_objective.activate()
def _xform_constraint(self, obj, disjunct, infodict, var_substitute_map,
zero_substitute_map):
# we will put a new transformed constraint on the relaxation block.
relaxationBlock = infodict['chull']['relaxationBlock']
transBlock = relaxationBlock.parent_block()
varMap = infodict['chull']['disaggregatedVars']
# Though rare, it is possible to get naming conflicts here
# since constraints from all blocks are getting moved onto the
# same block. So we get a unique name
name = unique_component_name(relaxationBlock, obj.name)
if obj.is_indexed():
try:
newConstraint = Constraint(obj.index_set(), transBlock.lbub)
except:
# The original constraint may have been indexed by a
# non-concrete set (like an Any). We will give up on
# strict index verification and just blindly proceed.
newConstraint = Constraint(Any)
else:
newConstraint = Constraint(transBlock.lbub)
relaxationBlock.add_component(name, newConstraint)
# add mapping of original constraint to transformed constraint
# in transformation info dictionary
infodict['chull']['relaxedConstraints'][obj] = newConstraint
# add mapping of transformed constraint back to original constraint (we
# know that the info dict is already created because this only got
# called if we were transforming a disjunct...)
relaxationBlock._gdp_transformation_info['srcConstraints'][
newConstraint] = obj
for i in sorted(iterkeys(obj)):
c = obj[i]
if not c.active:
continue
NL = c.body.polynomial_degree() not in (0, 1)
EPS = self._config.EPS
mode = self._config.perspective_function
# We need to evaluate the expression at the origin *before*
# we substitute the expression variables with the
# disaggregated variables
if not NL or mode == "FurmanSawayaGrossmann":
h_0 = clone_without_expression_components(
c.body, substitute=zero_substitute_map)
y = disjunct.indicator_var
if NL:
if mode == "LeeGrossmann":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs / y)
for var, subs in iteritems(var_substitute_map)))
expr = sub_expr * y
elif mode == "GrossmannLee":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs / (y + EPS))
for var, subs in iteritems(var_substitute_map)))
expr = (y + EPS) * sub_expr
elif mode == "FurmanSawayaGrossmann":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs / ((1 - EPS) * y + EPS))
for var, subs in iteritems(var_substitute_map)))
expr = (
(1 - EPS) * y + EPS) * sub_expr - EPS * h_0 * (1 - y)
else:
raise RuntimeError("Unknown NL CHull mode")
else:
expr = clone_without_expression_components(
c.body, substitute=var_substitute_map)
if c.equality:
if NL:
newConsExpr = expr == c.lower * y
else:
v = list(EXPR.identify_variables(expr))
if len(v) == 1 and not c.lower:
# Setting a variable to 0 in a disjunct is
# *very* common. We should recognize that in
# that structure, the disaggregated variable
# will also be fixed to 0.
v[0].fix(0)
continue
newConsExpr = expr - (1 - y) * h_0 == c.lower * y
if obj.is_indexed():
newConstraint.add((i, 'eq'), newConsExpr)
else:
newConstraint.add('eq', newConsExpr)
continue
if c.lower is not None:
# TODO: At the moment there is no reason for this to be in both
# lower and upper... I think there could be though if I say what
# the new constraint is going to be or something.
if __debug__ and logger.isEnabledFor(logging.DEBUG):
logger.debug(
"GDP(cHull): Transforming constraint " + "'%s'",
c.name)
if NL:
newConsExpr = expr >= c.lower * y
else:
newConsExpr = expr - (1 - y) * h_0 >= c.lower * y
if obj.is_indexed():
newConstraint.add((i, 'lb'), newConsExpr)
else:
newConstraint.add('lb', newConsExpr)
if c.upper is not None:
if __debug__ and logger.isEnabledFor(logging.DEBUG):
logger.debug(
"GDP(cHull): Transforming constraint " + "'%s'",
c.name)
if NL:
newConsExpr = expr <= c.upper * y
else:
newConsExpr = expr - (1 - y) * h_0 <= c.upper * y
if obj.is_indexed():
newConstraint.add((i, 'ub'), newConsExpr)
else:
newConstraint.add('ub', newConsExpr)
def _transform_constraint(self, obj, disjunct, var_substitute_map,
zero_substitute_map):
# we will put a new transformed constraint on the relaxation block.
relaxationBlock = disjunct._transformation_block()
transBlock = relaxationBlock.parent_block()
varMap = relaxationBlock._disaggregatedVarMap['disaggregatedVar']
constraintMap = relaxationBlock._constraintMap
# Though rare, it is possible to get naming conflicts here
# since constraints from all blocks are getting moved onto the
# same block. So we get a unique name
name = unique_component_name(
relaxationBlock,
obj.getname(fully_qualified=True, name_buffer=NAME_BUFFER))
if obj.is_indexed():
newConstraint = Constraint(obj.index_set(), transBlock.lbub)
else:
newConstraint = Constraint(transBlock.lbub)
relaxationBlock.add_component(name, newConstraint)
# map the containers:
# add mapping of original constraint to transformed constraint
if obj.is_indexed():
constraintMap['transformedConstraints'][obj] = newConstraint
# add mapping of transformed constraint container back to original
# constraint container (or SimpleConstraint)
constraintMap['srcConstraints'][newConstraint] = obj
for i in sorted(iterkeys(obj)):
c = obj[i]
if not c.active:
continue
NL = c.body.polynomial_degree() not in (0, 1)
EPS = self._config.EPS
mode = self._config.perspective_function
# We need to evaluate the expression at the origin *before*
# we substitute the expression variables with the
# disaggregated variables
if not NL or mode == "FurmanSawayaGrossmann":
h_0 = clone_without_expression_components(
c.body, substitute=zero_substitute_map)
y = disjunct.indicator_var
if NL:
if mode == "LeeGrossmann":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs / y)
for var, subs in iteritems(var_substitute_map)))
expr = sub_expr * y
elif mode == "GrossmannLee":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs / (y + EPS))
for var, subs in iteritems(var_substitute_map)))
expr = (y + EPS) * sub_expr
elif mode == "FurmanSawayaGrossmann":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs / ((1 - EPS) * y + EPS))
for var, subs in iteritems(var_substitute_map)))
expr = (
(1 - EPS) * y + EPS) * sub_expr - EPS * h_0 * (1 - y)
else:
raise RuntimeError("Unknown NL Hull mode")
else:
expr = clone_without_expression_components(
c.body, substitute=var_substitute_map)
if c.equality:
if NL:
# ESJ TODO: This can't happen right? This is the only
# obvious case where someone has messed up, but this has to
# be nonconvex, right? Shouldn't we tell them?
newConsExpr = expr == c.lower * y
else:
v = list(EXPR.identify_variables(expr))
if len(v) == 1 and not c.lower:
# Setting a variable to 0 in a disjunct is
# *very* common. We should recognize that in
# that structure, the disaggregated variable
# will also be fixed to 0.
v[0].fix(0)
# ESJ: If you ask where the transformed constraint is,
# the answer is nowhere. Really, it is in the bounds of
# this variable, so I'm going to return
# it. Alternatively we could return an empty list, but I
# think I like this better.
constraintMap['transformedConstraints'][c] = [v[0]]
# Reverse map also (this is strange)
constraintMap['srcConstraints'][v[0]] = c
continue
newConsExpr = expr - (1 - y) * h_0 == c.lower * y
if obj.is_indexed():
newConstraint.add((i, 'eq'), newConsExpr)
# map the _ConstraintDatas (we mapped the container above)
constraintMap['transformedConstraints'][c] = [
newConstraint[i, 'eq']
]
constraintMap['srcConstraints'][newConstraint[i, 'eq']] = c
else:
newConstraint.add('eq', newConsExpr)
# map to the _ConstraintData (And yes, for
# SimpleConstraints, this is overwriting the map to the
# container we made above, and that is what I want to
# happen. SimpleConstraints will map to lists. For
# IndexedConstraints, we can map the container to the
# container, but more importantly, we are mapping the
# _ConstraintDatas to each other above)
constraintMap['transformedConstraints'][c] = [
newConstraint['eq']
]
constraintMap['srcConstraints'][newConstraint['eq']] = c
continue
if c.lower is not None:
if __debug__ and logger.isEnabledFor(logging.DEBUG):
_name = c.getname(fully_qualified=True,
name_buffer=NAME_BUFFER)
logger.debug(
"GDP(Hull): Transforming constraint " + "'%s'", _name)
if NL:
newConsExpr = expr >= c.lower * y
else:
newConsExpr = expr - (1 - y) * h_0 >= c.lower * y
if obj.is_indexed():
newConstraint.add((i, 'lb'), newConsExpr)
constraintMap['transformedConstraints'][c] = [
newConstraint[i, 'lb']
]
constraintMap['srcConstraints'][newConstraint[i, 'lb']] = c
else:
newConstraint.add('lb', newConsExpr)
constraintMap['transformedConstraints'][c] = [
newConstraint['lb']
]
constraintMap['srcConstraints'][newConstraint['lb']] = c
if c.upper is not None:
if __debug__ and logger.isEnabledFor(logging.DEBUG):
_name = c.getname(fully_qualified=True,
name_buffer=NAME_BUFFER)
logger.debug(
"GDP(Hull): Transforming constraint " + "'%s'", _name)
if NL:
newConsExpr = expr <= c.upper * y
else:
newConsExpr = expr - (1 - y) * h_0 <= c.upper * y
if obj.is_indexed():
newConstraint.add((i, 'ub'), newConsExpr)
# map (have to account for fact we might have created list
# above
transformed = constraintMap['transformedConstraints'].get(
c)
if transformed is not None:
transformed.append(newConstraint[i, 'ub'])
else:
constraintMap['transformedConstraints'][c] = [
newConstraint[i, 'ub']
]
constraintMap['srcConstraints'][newConstraint[i, 'ub']] = c
else:
newConstraint.add('ub', newConsExpr)
transformed = constraintMap['transformedConstraints'].get(
c)
if transformed is not None:
transformed.append(newConstraint['ub'])
else:
constraintMap['transformedConstraints'][c] = [
newConstraint['ub']
]
constraintMap['srcConstraints'][newConstraint['ub']] = c
# deactivate now that we have transformed
obj.deactivate()
def _xform_constraint(self, obj, disjunct, infodict, var_substitute_map,
zero_substitute_map):
# we will put a new transformed constraint on the relaxation block.
relaxationBlock = infodict['chull']['relaxationBlock']
transBlock = relaxationBlock.parent_block()
varMap = infodict['chull']['disaggregatedVars']
# Though rare, it is possible to get naming conflicts here
# since constraints from all blocks are getting moved onto the
# same block. So we get a unique name
name = unique_component_name(relaxationBlock, obj.name)
if obj.is_indexed():
try:
newConstraint = Constraint(obj.index_set(), transBlock.lbub)
except:
# The original constraint may have been indexed by a
# non-concrete set (like an Any). We will give up on
# strict index verification and just blindly proceed.
newConstraint = Constraint(Any)
else:
newConstraint = Constraint(transBlock.lbub)
relaxationBlock.add_component(name, newConstraint)
# add mapping of original constraint to transformed constraint
# in transformation info dictionary
infodict['chull']['relaxedConstraints'][obj] = newConstraint
# add mapping of transformed constraint back to original constraint (we
# know that the info dict is already created because this only got
# called if we were transforming a disjunct...)
relaxationBlock._gdp_transformation_info['srcConstraints'][
newConstraint] = obj
for i in sorted(iterkeys(obj)):
c = obj[i]
if not c.active:
continue
NL = c.body.polynomial_degree() not in (0,1)
EPS = self._config.EPS
mode = self._config.perspective_function
# We need to evaluate the expression at the origin *before*
# we substitute the expression variables with the
# disaggregated variables
if not NL or mode == "FurmanSawayaGrossmann":
h_0 = clone_without_expression_components(
c.body, substitute=zero_substitute_map)
y = disjunct.indicator_var
if NL:
if mode == "LeeGrossmann":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs/y)
for var, subs in iteritems(var_substitute_map) )
)
expr = sub_expr * y
elif mode == "GrossmannLee":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs/(y + EPS))
for var, subs in iteritems(var_substitute_map) )
)
expr = (y + EPS) * sub_expr
elif mode == "FurmanSawayaGrossmann":
sub_expr = clone_without_expression_components(
c.body,
substitute=dict(
(var, subs/((1 - EPS)*y + EPS))
for var, subs in iteritems(var_substitute_map) )
)
expr = ((1-EPS)*y + EPS)*sub_expr - EPS*h_0*(1-y)
else:
raise RuntimeError("Unknown NL CHull mode")
else:
expr = clone_without_expression_components(
c.body, substitute=var_substitute_map)
if c.equality:
if NL:
newConsExpr = expr == c.lower*y
else:
v = list(EXPR.identify_variables(expr))
if len(v) == 1 and not c.lower:
# Setting a variable to 0 in a disjunct is
# *very* common. We should recognize that in
# that structure, the disaggregated variable
# will also be fixed to 0.
v[0].fix(0)
continue
newConsExpr = expr - (1-y)*h_0 == c.lower*y
if obj.is_indexed():
newConstraint.add((i, 'eq'), newConsExpr)
else:
newConstraint.add('eq', newConsExpr)
continue
if c.lower is not None:
# TODO: At the moment there is no reason for this to be in both
# lower and upper... I think there could be though if I say what
# the new constraint is going to be or something.
if __debug__ and logger.isEnabledFor(logging.DEBUG):
logger.debug("GDP(cHull): Transforming constraint " +
"'%s'", c.name)
if NL:
newConsExpr = expr >= c.lower*y
else:
newConsExpr = expr - (1-y)*h_0 >= c.lower*y
if obj.is_indexed():
newConstraint.add((i, 'lb'), newConsExpr)
else:
newConstraint.add('lb', newConsExpr)
if c.upper is not None:
if __debug__ and logger.isEnabledFor(logging.DEBUG):
logger.debug("GDP(cHull): Transforming constraint " +
"'%s'", c.name)
if NL:
newConsExpr = expr <= c.upper*y
else:
newConsExpr = expr - (1-y)*h_0 <= c.upper*y
if obj.is_indexed():
newConstraint.add((i, 'ub'), newConsExpr)
else:
newConstraint.add('ub', newConsExpr)
