def handle_main_unbounded(main_mip, solve_data, config):
"""This function handles the result of the latest iteration of solving the MIP
problem given an unbounded solution due to the relaxation.
Args:
main_mip (Pyomo model): the MIP main problem.
solve_data (MindtPySolveData): data container that holds solve-instance data.
config (ConfigBlock): the specific configurations for MindtPy.
Returns:
main_mip_results (SolverResults): the results of the bounded main problem.
"""
# Solution is unbounded. Add an arbitrary bound to the objective and resolve.
# This occurs when the objective is nonlinear. The nonlinear objective is moved
# to the constraints, and deactivated for the linear main problem.
MindtPy = main_mip.MindtPy_utils
config.logger.warning(
'main MILP was unbounded. '
'Resolving with arbitrary bound values of (-{0:.10g}, {0:.10g}) on the objective. '
'You can change this bound with the option obj_bound.'.format(
config.obj_bound))
MindtPy.objective_bound = Constraint(expr=(-config.obj_bound,
MindtPy.mip_obj.expr,
config.obj_bound))
mainopt = SolverFactory(config.mip_solver)
if isinstance(mainopt, PersistentSolver):
mainopt.set_instance(main_mip)
set_solver_options(mainopt, solve_data, config, solver_type='mip')
with SuppressInfeasibleWarning():
main_mip_results = mainopt.solve(main_mip,
tee=config.mip_solver_tee,
**config.mip_solver_args)
return main_mip_results
def handle_master_mip_unbounded(master_mip, solve_data, config):
"""
This function handles the result of the latest iteration of solving the MIP problem given an unbounded solution
due to the relaxation.
Parameters
----------
master_mip: Pyomo model
the MIP master problem
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
"""
# Solution is unbounded. Add an arbitrary bound to the objective and resolve.
# This occurs when the objective is nonlinear. The nonlinear objective is moved
# to the constraints, and deactivated for the linear master problem.
MindtPy = master_mip.MindtPy_utils
config.logger.warning(
'Master MILP was unbounded. '
'Resolving with arbitrary bound values of (-{0:.10g}, {0:.10g}) on the objective. '
'You can change this bound with the option obj_bound.'.format(
config.obj_bound))
main_objective = next(
master_mip.component_data_objects(Objective, active=True))
MindtPy.objective_bound = Constraint(expr=(-config.obj_bound,
main_objective.expr,
config.obj_bound))
with SuppressInfeasibleWarning():
opt = SolverFactory(config.mip_solver)
if isinstance(opt, PersistentSolver):
opt.set_instance(master_mip)
master_mip_results = opt.solve(master_mip,
tee=config.solver_tee,
**config.mip_solver_args)
def init_rNLP(solve_data, config):
"""Initialize by solving the rNLP (relaxed binary variables)."""
solve_data.nlp_iter += 1
m = solve_data.working_model.clone()
config.logger.info("NLP %s: Solve relaxed integrality" %
(solve_data.nlp_iter, ))
MindtPy = m.MindtPy_utils
TransformationFactory('core.relax_integrality').apply_to(m)
with SuppressInfeasibleWarning():
results = SolverFactory(config.nlp_solver).solve(
m, **config.nlp_solver_args)
subprob_terminate_cond = results.solver.termination_condition
if subprob_terminate_cond is tc.optimal:
main_objective = next(m.component_data_objects(Objective, active=True))
nlp_solution_values = list(v.value for v in MindtPy.variable_list)
dual_values = list(m.dual[c] for c in MindtPy.constraint_list)
# Add OA cut
if main_objective.sense == minimize:
solve_data.LB = value(main_objective.expr)
else:
solve_data.UB = value(main_objective.expr)
config.logger.info('NLP %s: OBJ: %s LB: %s UB: %s' %
(solve_data.nlp_iter, value(main_objective.expr),
solve_data.LB, solve_data.UB))
if config.strategy == 'OA':
add_oa_cut(nlp_solution_values, dual_values, solve_data, config)
elif subprob_terminate_cond is tc.infeasible:
# TODO fail? try something else?
config.logger.info('Initial relaxed NLP problem is infeasible. '
'Problem may be infeasible.')
else:
raise ValueError(
'MindtPy unable to handle relaxed NLP termination condition '
'of %s. Solver message: %s' %
(subprob_terminate_cond, results.solver.message))
def solve_feasibility_subproblem(solve_data, config):
"""Solves a feasibility NLP if the fixed_nlp problem is infeasible.
Args:
solve_data (MindtPySolveData): data container that holds solve-instance data.
config (ConfigBlock): the specific configurations for MindtPy.
Returns:
feas_subproblem (Pyomo model): feasibility NLP from the model.
feas_soln (SolverResults): results from solving the feasibility NLP.
"""
feas_subproblem = solve_data.working_model.clone()
add_feas_slacks(feas_subproblem, config)
MindtPy = feas_subproblem.MindtPy_utils
if MindtPy.find_component('objective_value') is not None:
MindtPy.objective_value.value = 0
next(feas_subproblem.component_data_objects(
Objective, active=True)).deactivate()
for constr in feas_subproblem.MindtPy_utils.nonlinear_constraint_list:
constr.deactivate()
MindtPy.feas_opt.activate()
if config.feasibility_norm == 'L1':
MindtPy.feas_obj = Objective(
expr=sum(s for s in MindtPy.feas_opt.slack_var[...]),
sense=minimize)
elif config.feasibility_norm == 'L2':
MindtPy.feas_obj = Objective(
expr=sum(s*s for s in MindtPy.feas_opt.slack_var[...]),
sense=minimize)
else:
MindtPy.feas_obj = Objective(
expr=MindtPy.feas_opt.slack_var,
sense=minimize)
TransformationFactory('core.fix_integer_vars').apply_to(feas_subproblem)
nlpopt = SolverFactory(config.nlp_solver)
nlp_args = dict(config.nlp_solver_args)
set_solver_options(nlpopt, solve_data, config, solver_type='nlp')
with SuppressInfeasibleWarning():
try:
with time_code(solve_data.timing, 'feasibility subproblem'):
feas_soln = nlpopt.solve(
feas_subproblem, tee=config.nlp_solver_tee, **nlp_args)
except (ValueError, OverflowError) as error:
for nlp_var, orig_val in zip(
MindtPy.variable_list,
solve_data.initial_var_values):
if not nlp_var.fixed and not nlp_var.is_binary():
nlp_var.set_value(orig_val, skip_validation=True)
with time_code(solve_data.timing, 'feasibility subproblem'):
feas_soln = nlpopt.solve(
feas_subproblem, tee=config.nlp_solver_tee, **nlp_args)
handle_feasibility_subproblem_tc(
feas_soln.solver.termination_condition, MindtPy, solve_data, config)
return feas_subproblem, feas_soln
def solve_NLP_feas(solve_data, config):
"""Solves feasibility NLP and copies result to working model
Returns: Result values and dual values
"""
fixed_nlp = solve_data.working_model.clone()
add_feas_slacks(fixed_nlp, config)
MindtPy = fixed_nlp.MindtPy_utils
next(fixed_nlp.component_data_objects(Objective, active=True)).deactivate()
for constr in fixed_nlp.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
if constr.body.polynomial_degree() not in [0, 1]:
constr.deactivate()
MindtPy.MindtPy_feas.activate()
if config.feasibility_norm == 'L1':
MindtPy.MindtPy_feas_obj = Objective(expr=sum(
s for s in MindtPy.MindtPy_feas.slack_var[...]),
sense=minimize)
elif config.feasibility_norm == 'L2':
MindtPy.MindtPy_feas_obj = Objective(expr=sum(
s * s for s in MindtPy.MindtPy_feas.slack_var[...]),
sense=minimize)
else:
MindtPy.MindtPy_feas_obj = Objective(
expr=MindtPy.MindtPy_feas.slack_var, sense=minimize)
TransformationFactory('core.fix_integer_vars').apply_to(fixed_nlp)
with SuppressInfeasibleWarning():
feas_soln = SolverFactory(config.nlp_solver).solve(
fixed_nlp, **config.nlp_solver_args)
subprob_terminate_cond = feas_soln.solver.termination_condition
if subprob_terminate_cond is tc.optimal or subprob_terminate_cond is tc.locallyOptimal:
copy_var_list_values(
MindtPy.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
elif subprob_terminate_cond is tc.infeasible:
raise ValueError('Feasibility NLP infeasible. '
'This should never happen.')
else:
raise ValueError(
'MindtPy unable to handle feasibility NLP termination condition '
'of {}'.format(subprob_terminate_cond))
var_values = [v.value for v in MindtPy.variable_list]
duals = [0 for _ in MindtPy.constraint_list]
for i, c in enumerate(MindtPy.constraint_list):
rhs = c.upper if c.has_ub() else c.lower
c_geq = -1 if c.has_ub() else 1
duals[i] = c_geq * max(0, c_geq * (rhs - value(c.body)))
if value(MindtPy.MindtPy_feas_obj.expr) == 0:
raise ValueError('Problem is not feasible, check NLP solver')
return fixed_nlp, feas_soln
def solve_NLP_feas(solve_data, config):
"""Solves feasibility NLP and copies result to working model
Returns: Result values and dual values
"""
fix_nlp = solve_data.working_model.clone()
add_feas_slacks(fix_nlp)
MindtPy = fix_nlp.MindtPy_utils
next(fix_nlp.component_data_objects(Objective, active=True)).deactivate()
for constr in fix_nlp.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
if constr.body.polynomial_degree() not in [0, 1]:
constr.deactivate()
MindtPy.MindtPy_feas.activate()
MindtPy.MindtPy_feas_obj = Objective(expr=sum(
s for s in MindtPy.MindtPy_feas.slack_var[...]),
sense=minimize)
TransformationFactory('core.fix_discrete').apply_to(fix_nlp)
with SuppressInfeasibleWarning():
feas_soln = SolverFactory(config.nlp_solver).solve(
fix_nlp, **config.nlp_solver_args)
subprob_terminate_cond = feas_soln.solver.termination_condition
if subprob_terminate_cond is tc.optimal:
copy_var_list_values(
MindtPy.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
elif subprob_terminate_cond is tc.infeasible:
raise ValueError('Feasibility NLP infeasible. '
'This should never happen.')
else:
raise ValueError(
'MindtPy unable to handle feasibility NLP termination condition '
'of {}'.format(subprob_terminate_cond))
var_values = [v.value for v in MindtPy.variable_list]
duals = [0 for _ in MindtPy.constraint_list]
for i, constr in enumerate(MindtPy.constraint_list):
# TODO rhs only works if constr.upper and constr.lower do not both have values.
# Sometimes you might have 1 <= expr <= 1. This would give an incorrect rhs of 2.
rhs = ((0 if constr.upper is None else constr.upper) +
(0 if constr.lower is None else constr.lower))
sign_adjust = 1 if value(constr.upper) is None else -1
duals[i] = sign_adjust * max(0, sign_adjust *
(rhs - value(constr.body)))
if value(MindtPy.MindtPy_feas_obj.expr) == 0:
raise ValueError('Problem is not feasible, check NLP solver')
return fix_nlp, feas_soln
def solve_linear_subproblem(mip_model, solve_data, config):
GDPopt = mip_model.GDPopt_utils
initialize_subproblem(mip_model, solve_data)
# Callback immediately before solving NLP subproblem
config.call_before_subproblem_solve(mip_model, solve_data)
mip_solver = SolverFactory(config.mip_solver)
if not mip_solver.available():
raise RuntimeError("MIP solver %s is not available." %
config.mip_solver)
with SuppressInfeasibleWarning():
mip_args = dict(config.mip_solver_args)
elapsed = get_main_elapsed_time(solve_data.timing)
remaining = max(config.time_limit - elapsed, 1)
if config.mip_solver == 'gams':
mip_args['add_options'] = mip_args.get('add_options', [])
mip_args['add_options'].append('option reslim=%s;' % remaining)
elif config.mip_solver == 'multisolve':
mip_args['time_limit'] = min(
mip_args.get('time_limit', float('inf')), remaining)
results = mip_solver.solve(mip_model, **mip_args)
subprob_result = SubproblemResult()
subprob_result.feasible = True
subprob_result.var_values = list(v.value for v in GDPopt.variable_list)
subprob_result.pyomo_results = results
subprob_result.dual_values = list(
mip_model.dual.get(c, None) for c in GDPopt.constraint_list)
subprob_terminate_cond = results.solver.termination_condition
if subprob_terminate_cond is tc.optimal:
pass
elif subprob_terminate_cond is tc.infeasible:
config.logger.info('MIP subproblem was infeasible.')
subprob_result.feasible = False
else:
raise ValueError('GDPopt unable to handle MIP subproblem termination '
'condition of %s. Results: %s' %
(subprob_terminate_cond, results))
# Call the NLP post-solve callback
config.call_after_subproblem_solve(mip_model, solve_data)
# if feasible, call the NLP post-feasible callback
if subprob_result.feasible:
config.call_after_subproblem_feasible(mip_model, solve_data)
return subprob_result
def solve_NLP_feas(solve_data, config):
m = solve_data.working_model.clone()
add_feas_slacks(m)
MindtPy = m.MindtPy_utils
next(m.component_data_objects(Objective, active=True)).deactivate()
for constr in m.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
constr.deactivate()
MindtPy.MindtPy_feas.activate()
MindtPy.MindtPy_feas_obj = Objective(expr=sum(
s for s in MindtPy.MindtPy_feas.slack_var[...]),
sense=minimize)
for v in MindtPy.variable_list:
if v.is_binary():
v.fix(int(round(v.value)))
# m.pprint() #print nlp feasibility problem for debugging
with SuppressInfeasibleWarning():
feas_soln = SolverFactory(config.nlp_solver).solve(
m, **config.nlp_solver_args)
subprob_terminate_cond = feas_soln.solver.termination_condition
if subprob_terminate_cond is tc.optimal:
copy_var_list_values(
MindtPy.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
pass
elif subprob_terminate_cond is tc.infeasible:
raise ValueError('Feasibility NLP infeasible. '
'This should never happen.')
else:
raise ValueError(
'MindtPy unable to handle feasibility NLP termination condition '
'of {}'.format(subprob_terminate_cond))
var_values = [v.value for v in MindtPy.variable_list]
duals = [0 for _ in MindtPy.constraint_list]
for i, constr in enumerate(MindtPy.constraint_list):
# TODO rhs only works if constr.upper and constr.lower do not both have values.
# Sometimes you might have 1 <= expr <= 1. This would give an incorrect rhs of 2.
rhs = ((0 if constr.upper is None else constr.upper) +
(0 if constr.lower is None else constr.lower))
sign_adjust = 1 if value(constr.upper) is None else -1
duals[i] = sign_adjust * max(0, sign_adjust *
(rhs - value(constr.body)))
if value(MindtPy.MindtPy_feas_obj.expr) == 0:
raise ValueError('Problem is not feasible, check NLP solver')
return var_values, duals
def distinguish_mip_infeasible_or_unbounded(m, config):
"""Distinguish between an infeasible or unbounded solution.
Linear solvers will sometimes tell me that a problem is infeasible or
unbounded during presolve, but not distinguish between the two cases. We
address this by solving again with a solver option flag on.
"""
tmp_args = deepcopy(config.mip_solver_args)
# TODO This solver option is specific to Gurobi.
tmp_args['options']['DualReductions'] = 0
with SuppressInfeasibleWarning():
results = SolverFactory(config.mip_solver).solve(m, **tmp_args)
termination_condition = results.solver.termination_condition
return results, termination_condition
def solve_NLP_subproblem(solve_data, config):
""" Solves fixed NLP with fixed working model binaries
Sets up local working model `fix_nlp`
Fixes binaries
Sets continuous variables to initial var values
Precomputes dual values
Deactivates trivial constraints
Solves NLP model
Returns the fixed-NLP model and the solver results
"""
fix_nlp = solve_data.working_model.clone()
MindtPy = fix_nlp.MindtPy_utils
main_objective = next(
fix_nlp.component_data_objects(Objective, active=True))
solve_data.nlp_iter += 1
config.logger.info('NLP %s: Solve subproblem for fixed binaries.' %
(solve_data.nlp_iter, ))
# Set up NLP
TransformationFactory('core.fix_discrete').apply_to(fix_nlp)
# restore original variable values
for nlp_var, orig_val in zip(MindtPy.variable_list,
solve_data.initial_var_values):
if not nlp_var.fixed and not nlp_var.is_binary():
nlp_var.value = orig_val
MindtPy.MindtPy_linear_cuts.deactivate()
fix_nlp.tmp_duals = ComponentMap()
for c in fix_nlp.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
rhs = ((0 if c.upper is None else c.upper) +
(0 if c.lower is None else c.lower))
sign_adjust = 1 if value(c.upper) is None else -1
fix_nlp.tmp_duals[c] = sign_adjust * max(
0, sign_adjust * (rhs - value(c.body)))
# TODO check sign_adjust
TransformationFactory('contrib.deactivate_trivial_constraints')\
.apply_to(fix_nlp, tmp=True, ignore_infeasible=True)
# Solve the NLP
with SuppressInfeasibleWarning():
results = SolverFactory(config.nlp_solver).solve(
fix_nlp, **config.nlp_solver_args)
return fix_nlp, results
def handle_master_mip_unbounded(master_mip, solve_data, config):
# Solution is unbounded. Add an arbitrary bound to the objective and resolve.
# This occurs when the objective is nonlinear. The nonlinear objective is moved
# to the constraints, and deactivated for the linear master problem.
MindtPy = master_mip.MindtPy_utils
config.logger.warning(
'Master MILP was unbounded. '
'Resolving with arbitrary bound values of (-{0:.10g}, {0:.10g}) on the objective. '
'You can change this bound with the option obj_bound.'.format(
config.obj_bound))
main_objective = next(
master_mip.component_data_objects(Objective, active=True))
MindtPy.objective_bound = Constraint(expr=(-config.obj_bound,
main_objective.expr,
config.obj_bound))
with SuppressInfeasibleWarning():
master_mip_results = SolverFactory(config.mip_solver).solve(
master_mip, **config.mip_solver_args)
def solve_OA_master(solve_data, config):
solve_data.mip_iter += 1
master_mip = solve_data.mip.clone()
MindtPy = master_mip.MindtPy_utils
config.logger.info('MIP %s: Solve master problem.' %
(solve_data.mip_iter, ))
# Set up MILP
for c in MindtPy.constraint_list:
if c.body.polynomial_degree() not in (1, 0):
c.deactivate()
MindtPy.MindtPy_linear_cuts.activate()
main_objective = next(
master_mip.component_data_objects(Objective, active=True))
main_objective.deactivate()
sign_adjust = 1 if main_objective.sense == minimize else -1
MindtPy.MindtPy_penalty_expr = Expression(
expr=sign_adjust * config.OA_penalty_factor *
sum(v for v in MindtPy.MindtPy_linear_cuts.slack_vars[...]))
MindtPy.MindtPy_oa_obj = Objective(expr=main_objective.expr +
MindtPy.MindtPy_penalty_expr,
sense=main_objective.sense)
# Deactivate extraneous IMPORT/EXPORT suffixes
getattr(master_mip, 'ipopt_zL_out', _DoNothing()).deactivate()
getattr(master_mip, 'ipopt_zU_out', _DoNothing()).deactivate()
# master_mip.pprint() #print oa master problem for debugging
with SuppressInfeasibleWarning():
master_mip_results = SolverFactory(config.mip_solver).solve(
master_mip, **config.mip_solver_args)
if master_mip_results.solver.termination_condition is tc.infeasibleOrUnbounded:
# Linear solvers will sometimes tell me that it's infeasible or
# unbounded during presolve, but fails to distinguish. We need to
# resolve with a solver option flag on.
master_mip_results, _ = distinguish_mip_infeasible_or_unbounded(
master_mip, config)
return master_mip, master_mip_results
def solve_linear_subproblem(mip_model, solve_data, config):
GDPopt = mip_model.GDPopt_utils
initialize_subproblem(mip_model, solve_data)
# Callback immediately before solving NLP subproblem
config.call_before_subproblem_solve(mip_model, solve_data)
mip_solver = SolverFactory(config.mip_solver)
if not mip_solver.available():
raise RuntimeError("MIP solver %s is not available." %
config.mip_solver)
with SuppressInfeasibleWarning():
results = mip_solver.solve(mip_model, **config.mip_solver_args)
subprob_result = SubproblemResult()
subprob_result.feasible = True
subprob_result.var_values = list(v.value for v in GDPopt.variable_list)
subprob_result.pyomo_results = results
subprob_result.dual_values = list(
mip_model.dual.get(c, None) for c in GDPopt.constraint_list)
subprob_terminate_cond = results.solver.termination_condition
if subprob_terminate_cond is tc.optimal:
pass
elif subprob_terminate_cond is tc.infeasible:
config.logger.info('MIP subproblem was infeasible.')
subprob_result.feasible = False
else:
raise ValueError('GDPopt unable to handle MIP subproblem termination '
'condition of %s. Results: %s' %
(subprob_terminate_cond, results))
# Call the NLP post-solve callback
config.call_after_subproblem_solve(mip_model, solve_data)
# if feasible, call the NLP post-feasible callback
if subprob_result.feasible:
config.call_after_subproblem_feasible(mip_model, solve_data)
return subprob_result
def solve_NLP_subproblem(solve_data, config):
m = solve_data.working_model.clone()
MindtPy = m.MindtPy_utils
main_objective = next(m.component_data_objects(Objective, active=True))
solve_data.nlp_iter += 1
config.logger.info('NLP %s: Solve subproblem for fixed binaries.' %
(solve_data.nlp_iter, ))
# Set up NLP
for v in MindtPy.variable_list:
if v.is_binary():
v.fix(int(round(value(v))))
# restore original variable values
for nlp_var, orig_val in zip(MindtPy.variable_list,
solve_data.initial_var_values):
if not nlp_var.fixed and not nlp_var.is_binary():
nlp_var.value = orig_val
MindtPy.MindtPy_linear_cuts.deactivate()
m.tmp_duals = ComponentMap()
for c in m.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
rhs = ((0 if c.upper is None else c.upper) +
(0 if c.lower is None else c.lower))
sign_adjust = 1 if value(c.upper) is None else -1
m.tmp_duals[c] = sign_adjust * max(0,
sign_adjust * (rhs - value(c.body)))
# TODO check sign_adjust
t = TransformationFactory('contrib.deactivate_trivial_constraints')
t.apply_to(m, tmp=True, ignore_infeasible=True)
# Solve the NLP
# m.pprint() # print nlp problem for debugging
with SuppressInfeasibleWarning():
results = SolverFactory(config.nlp_solver).solve(
m, **config.nlp_solver_args)
var_values = list(v.value for v in MindtPy.variable_list)
subprob_terminate_cond = results.solver.termination_condition
if subprob_terminate_cond is tc.optimal:
copy_var_list_values(
m.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
for c in m.tmp_duals:
if m.dual.get(c, None) is None:
m.dual[c] = m.tmp_duals[c]
duals = list(m.dual[c] for c in MindtPy.constraint_list)
if main_objective.sense == minimize:
solve_data.UB = min(value(main_objective.expr), solve_data.UB)
solve_data.solution_improved = solve_data.UB < solve_data.UB_progress[
-1]
solve_data.UB_progress.append(solve_data.UB)
else:
solve_data.LB = max(value(main_objective.expr), solve_data.LB)
solve_data.solution_improved = solve_data.LB > solve_data.LB_progress[
-1]
solve_data.LB_progress.append(solve_data.LB)
config.logger.info('NLP {}: OBJ: {} LB: {} UB: {}'.format(
solve_data.nlp_iter, value(main_objective.expr), solve_data.LB,
solve_data.UB))
if solve_data.solution_improved:
solve_data.best_solution_found = m.clone()
# Add the linear cut
if config.strategy == 'OA':
add_oa_cut(var_values, duals, solve_data, config)
elif config.strategy == 'PSC':
add_psc_cut(solve_data, config)
elif config.strategy == 'GBD':
add_gbd_cut(solve_data, config)
# This adds an integer cut to the feasible_integer_cuts
# ConstraintList, which is not activated by default. However, it
# may be activated as needed in certain situations or for certain
# values of option flags.
add_int_cut(var_values, solve_data, config, feasible=True)
config.call_after_subproblem_feasible(m, solve_data)
elif subprob_terminate_cond is tc.infeasible:
# TODO try something else? Reinitialize with different initial
# value?
config.logger.info('NLP subproblem was locally infeasible.')
for c in m.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
rhs = ((0 if c.upper is None else c.upper) +
(0 if c.lower is None else c.lower))
sign_adjust = 1 if value(c.upper) is None else -1
m.dual[c] = sign_adjust * max(0, sign_adjust *
(rhs - value(c.body)))
for var in m.component_data_objects(ctype=Var, descend_into=True):
if config.strategy == 'PSC' or config.strategy == 'GBD':
m.ipopt_zL_out[var] = 0
m.ipopt_zU_out[var] = 0
if var.ub is not None and abs(
var.ub - value(var)) < config.bound_tolerance:
m.ipopt_zL_out[var] = 1
elif var.lb is not None and abs(
value(var) - var.lb) < config.bound_tolerance:
m.ipopt_zU_out[var] = -1
# m.pprint() #print infeasible nlp problem for debugging
if config.strategy == 'OA':
config.logger.info('Solving feasibility problem')
if config.initial_feas:
# add_feas_slacks(m, solve_data)
# config.initial_feas = False
var_values, duals = solve_NLP_feas(solve_data, config)
add_oa_cut(var_values, duals, solve_data, config)
# Add an integer cut to exclude this discrete option
add_int_cut(var_values, solve_data, config)
elif subprob_terminate_cond is tc.maxIterations:
# TODO try something else? Reinitialize with different initial
# value?
config.logger.info(
'NLP subproblem failed to converge within iteration limit.')
# Add an integer cut to exclude this discrete option
add_int_cut(solve_data, config)
else:
raise ValueError('MindtPy unable to handle NLP subproblem termination '
'condition of {}'.format(subprob_terminate_cond))
# Call the NLP post-solve callback
config.call_after_subproblem_solve(m, solve_data)
def solve_subproblem(solve_data, config):
"""Solves the Fixed-NLP (with fixed integers).
This function sets up the 'fixed_nlp' by fixing binaries, sets continuous variables to their intial var values,
precomputes dual values, deactivates trivial constraints, and then solves NLP model.
Parameters
----------
solve_data : MindtPySolveData
Data container that holds solve-instance data.
config : ConfigBlock
The specific configurations for MindtPy.
Returns
-------
fixed_nlp : Pyomo model
Integer-variable-fixed NLP model.
results : SolverResults
Results from solving the Fixed-NLP.
"""
fixed_nlp = solve_data.working_model.clone()
MindtPy = fixed_nlp.MindtPy_utils
solve_data.nlp_iter += 1
# Set up NLP
TransformationFactory('core.fix_integer_vars').apply_to(fixed_nlp)
MindtPy.cuts.deactivate()
if config.calculate_dual:
fixed_nlp.tmp_duals = ComponentMap()
# tmp_duals are the value of the dual variables stored before using deactivate trivial contraints
# The values of the duals are computed as follows: (Complementary Slackness)
#
# | constraint | c_geq | status at x1 | tmp_dual (violation) |
# |------------|-------|--------------|----------------------|
# | g(x) <= b | -1 | g(x1) <= b | 0 |
# | g(x) <= b | -1 | g(x1) > b | g(x1) - b |
# | g(x) >= b | +1 | g(x1) >= b | 0 |
# | g(x) >= b | +1 | g(x1) < b | b - g(x1) |
evaluation_error = False
for c in fixed_nlp.MindtPy_utils.constraint_list:
# We prefer to include the upper bound as the right hand side since we are
# considering c by default a (hopefully) convex function, which would make
# c >= lb a nonconvex inequality which we wouldn't like to add linearizations
# if we don't have to
rhs = value(c.upper) if c.has_ub() else value(c.lower)
c_geq = -1 if c.has_ub() else 1
try:
fixed_nlp.tmp_duals[c] = c_geq * max(
0, c_geq * (rhs - value(c.body)))
except (ValueError, OverflowError) as error:
fixed_nlp.tmp_duals[c] = None
evaluation_error = True
if evaluation_error:
for nlp_var, orig_val in zip(MindtPy.variable_list,
solve_data.initial_var_values):
if not nlp_var.fixed and not nlp_var.is_binary():
nlp_var.set_value(orig_val, skip_validation=True)
try:
TransformationFactory(
'contrib.deactivate_trivial_constraints').apply_to(
fixed_nlp,
tmp=True,
ignore_infeasible=False,
tolerance=config.constraint_tolerance)
except InfeasibleConstraintException:
config.logger.warning(
'infeasibility detected in deactivate_trivial_constraints')
results = SolverResults()
results.solver.termination_condition = tc.infeasible
return fixed_nlp, results
# Solve the NLP
nlpopt = SolverFactory(config.nlp_solver)
nlp_args = dict(config.nlp_solver_args)
set_solver_options(nlpopt, solve_data, config, solver_type='nlp')
with SuppressInfeasibleWarning():
with time_code(solve_data.timing, 'fixed subproblem'):
results = nlpopt.solve(fixed_nlp,
tee=config.nlp_solver_tee,
**nlp_args)
return fixed_nlp, results
def init_rNLP(solve_data, config):
"""Initialize the problem by solving the relaxed NLP and then store the optimal variable
values obtained from solving the rNLP.
Parameters
----------
solve_data : MindtPySolveData
Data container that holds solve-instance data.
config : ConfigBlock
The specific configurations for MindtPy.
Raises
------
ValueError
MindtPy unable to handle the termination condition of the relaxed NLP.
"""
m = solve_data.working_model.clone()
config.logger.debug('Relaxed NLP: Solve relaxed integrality')
MindtPy = m.MindtPy_utils
TransformationFactory('core.relax_integer_vars').apply_to(m)
nlp_args = dict(config.nlp_solver_args)
nlpopt = SolverFactory(config.nlp_solver)
set_solver_options(nlpopt, solve_data, config, solver_type='nlp')
with SuppressInfeasibleWarning():
results = nlpopt.solve(m, tee=config.nlp_solver_tee, **nlp_args)
subprob_terminate_cond = results.solver.termination_condition
if subprob_terminate_cond in {tc.optimal, tc.feasible, tc.locallyOptimal}:
main_objective = MindtPy.objective_list[-1]
if subprob_terminate_cond == tc.optimal:
update_dual_bound(solve_data, value(main_objective.expr))
else:
config.logger.info('relaxed NLP is not solved to optimality.')
update_suboptimal_dual_bound(solve_data, results)
dual_values = list(
m.dual[c] for c in
MindtPy.constraint_list) if config.calculate_dual else None
config.logger.info(
solve_data.log_formatter.format(
'-', 'Relaxed NLP', value(main_objective.expr), solve_data.LB,
solve_data.UB, solve_data.rel_gap,
get_main_elapsed_time(solve_data.timing)))
# Add OA cut
if config.strategy in {'OA', 'GOA', 'FP'}:
copy_var_list_values(m.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config,
ignore_integrality=True)
if config.init_strategy == 'FP':
copy_var_list_values(
m.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list,
config,
ignore_integrality=True)
if config.strategy in {'OA', 'FP'}:
add_oa_cuts(solve_data.mip, dual_values, solve_data, config)
elif config.strategy == 'GOA':
add_affine_cuts(solve_data, config)
for var in solve_data.mip.MindtPy_utils.discrete_variable_list:
# We don't want to trigger the reset of the global stale
# indicator, so we will set this variable to be "stale",
# knowing that set_value will switch it back to "not
# stale"
var.stale = True
var.set_value(int(round(var.value)), skip_validation=True)
elif subprob_terminate_cond in {tc.infeasible, tc.noSolution}:
# TODO fail? try something else?
config.logger.info('Initial relaxed NLP problem is infeasible. '
'Problem may be infeasible.')
elif subprob_terminate_cond is tc.maxTimeLimit:
config.logger.info(
'NLP subproblem failed to converge within time limit.')
solve_data.results.solver.termination_condition = tc.maxTimeLimit
elif subprob_terminate_cond is tc.maxIterations:
config.logger.info(
'NLP subproblem failed to converge within iteration limit.')
else:
raise ValueError(
'MindtPy unable to handle relaxed NLP termination condition '
'of %s. Solver message: %s' %
(subprob_terminate_cond, results.solver.message))
def solve_linear_GDP(linear_GDP_model, solve_data, config):
"""Solves the linear GDP model and attempts to resolve solution issues."""
m = linear_GDP_model
GDPopt = m.GDPopt_utils
# Transform disjunctions
_bigm = TransformationFactory('gdp.bigm')
_bigm.handlers[Port] = False
_bigm.apply_to(m)
preprocessing_transformations = [
# # Propagate variable bounds
# 'contrib.propagate_eq_var_bounds',
# # Detect fixed variables
# 'contrib.detect_fixed_vars',
# # Propagate fixed variables
# 'contrib.propagate_fixed_vars',
# # Remove zero terms in linear expressions
# 'contrib.remove_zero_terms',
# # Remove terms in equal to zero summations
# 'contrib.propagate_zero_sum',
# # Transform bound constraints
# 'contrib.constraints_to_var_bounds',
# # Detect fixed variables
# 'contrib.detect_fixed_vars',
# # Remove terms in equal to zero summations
# 'contrib.propagate_zero_sum',
# Remove trivial constraints
'contrib.deactivate_trivial_constraints',
]
if config.mip_presolve:
try:
fbbt(m, integer_tol=config.integer_tolerance)
for xfrm in preprocessing_transformations:
TransformationFactory(xfrm).apply_to(m)
except InfeasibleConstraintException:
config.logger.debug("MIP preprocessing detected infeasibility.")
mip_result = MasterProblemResult()
mip_result.feasible = False
mip_result.var_values = list(v.value for v in GDPopt.variable_list)
mip_result.pyomo_results = SolverResults()
mip_result.pyomo_results.solver.termination_condition = tc.error
mip_result.disjunct_values = list(disj.indicator_var.value
for disj in GDPopt.disjunct_list)
return mip_result
# Deactivate extraneous IMPORT/EXPORT suffixes
getattr(m, 'ipopt_zL_out', _DoNothing()).deactivate()
getattr(m, 'ipopt_zU_out', _DoNothing()).deactivate()
# Create solver, check availability
if not SolverFactory(config.mip_solver).available():
raise RuntimeError("MIP solver %s is not available." %
config.mip_solver)
# Callback immediately before solving MIP master problem
config.call_before_master_solve(m, solve_data)
try:
with SuppressInfeasibleWarning():
mip_args = dict(config.mip_solver_args)
elapsed = get_main_elapsed_time(solve_data.timing)
remaining = max(config.time_limit - elapsed, 1)
if config.mip_solver == 'gams':
mip_args['add_options'] = mip_args.get('add_options', [])
mip_args['add_options'].append('option reslim=%s;' % remaining)
elif config.mip_solver == 'multisolve':
mip_args['time_limit'] = min(
mip_args.get('time_limit', float('inf')), remaining)
results = SolverFactory(config.mip_solver).solve(m, **mip_args)
except RuntimeError as e:
if 'GAMS encountered an error during solve.' in str(e):
config.logger.warning(
"GAMS encountered an error in solve. Treating as infeasible.")
mip_result = MasterProblemResult()
mip_result.feasible = False
mip_result.var_values = list(v.value for v in GDPopt.variable_list)
mip_result.pyomo_results = SolverResults()
mip_result.pyomo_results.solver.termination_condition = tc.error
mip_result.disjunct_values = list(disj.indicator_var.value
for disj in GDPopt.disjunct_list)
return mip_result
else:
raise
terminate_cond = results.solver.termination_condition
if terminate_cond is tc.infeasibleOrUnbounded:
# Linear solvers will sometimes tell me that it's infeasible or
# unbounded during presolve, but fails to distinguish. We need to
# resolve with a solver option flag on.
results, terminate_cond = distinguish_mip_infeasible_or_unbounded(
m, config)
if terminate_cond is tc.unbounded:
# Solution is unbounded. Add an arbitrary bound to the objective and resolve.
# This occurs when the objective is nonlinear. The nonlinear objective is moved
# to the constraints, and deactivated for the linear master problem.
obj_bound = 1E15
config.logger.warning(
'Linear GDP was unbounded. '
'Resolving with arbitrary bound values of (-{0:.10g}, {0:.10g}) on the objective. '
'Check your initialization routine.'.format(obj_bound))
main_objective = next(m.component_data_objects(Objective, active=True))
GDPopt.objective_bound = Constraint(expr=(-obj_bound,
main_objective.expr,
obj_bound))
with SuppressInfeasibleWarning():
results = SolverFactory(config.mip_solver).solve(
m, **config.mip_solver_args)
terminate_cond = results.solver.termination_condition
# Build and return results object
mip_result = MasterProblemResult()
mip_result.feasible = True
mip_result.var_values = list(v.value for v in GDPopt.variable_list)
mip_result.pyomo_results = results
mip_result.disjunct_values = list(disj.indicator_var.value
for disj in GDPopt.disjunct_list)
if terminate_cond in {tc.optimal, tc.locallyOptimal, tc.feasible}:
pass
elif terminate_cond is tc.infeasible:
config.logger.info(
'Linear GDP is now infeasible. '
'GDPopt has finished exploring feasible discrete configurations.')
mip_result.feasible = False
elif terminate_cond is tc.maxTimeLimit:
# TODO check that status is actually ok and everything is feasible
config.logger.info(
'Unable to optimize linear GDP problem within time limit. '
'Using current solver feasible solution.')
elif (terminate_cond is tc.other
and results.solution.status is SolutionStatus.feasible):
# load the solution and suppress the warning message by setting
# solver status to ok.
config.logger.info('Linear GDP solver reported feasible solution, '
'but not guaranteed to be optimal.')
else:
raise ValueError('GDPopt unable to handle linear GDP '
'termination condition '
'of %s. Solver message: %s' %
(terminate_cond, results.solver.message))
return mip_result
def solve_NLP_feas(solve_data, config):
"""
Solves a feasibility NLP if the fixed_nlp problem is infeasible
Parameters
----------
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
Returns
-------
feas_nlp: Pyomo model
feasibility NLP from the model
feas_soln: Pyomo results object
result from solving the feasibility NLP
"""
feas_nlp = solve_data.working_model.clone()
add_feas_slacks(feas_nlp, config)
MindtPy = feas_nlp.MindtPy_utils
if MindtPy.find_component('objective_value') is not None:
MindtPy.objective_value.value = 0
next(feas_nlp.component_data_objects(Objective, active=True)).deactivate()
for constr in feas_nlp.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
if constr.body.polynomial_degree() not in [0, 1]:
constr.deactivate()
MindtPy.MindtPy_feas.activate()
if config.feasibility_norm == 'L1':
MindtPy.MindtPy_feas_obj = Objective(expr=sum(
s for s in MindtPy.MindtPy_feas.slack_var[...]),
sense=minimize)
elif config.feasibility_norm == 'L2':
MindtPy.MindtPy_feas_obj = Objective(expr=sum(
s * s for s in MindtPy.MindtPy_feas.slack_var[...]),
sense=minimize)
else:
MindtPy.MindtPy_feas_obj = Objective(
expr=MindtPy.MindtPy_feas.slack_var, sense=minimize)
TransformationFactory('core.fix_integer_vars').apply_to(feas_nlp)
with SuppressInfeasibleWarning():
try:
nlpopt = SolverFactory(config.nlp_solver)
nlp_args = dict(config.nlp_solver_args)
elapsed = get_main_elapsed_time(solve_data.timing)
remaining = int(max(config.time_limit - elapsed, 1))
if config.nlp_solver == 'gams':
nlp_args['add_options'] = nlp_args.get('add_options', [])
nlp_args['add_options'].append('option reslim=%s;' % remaining)
feas_soln = nlpopt.solve(feas_nlp,
tee=config.solver_tee,
**nlp_args)
except (ValueError, OverflowError) as error:
for nlp_var, orig_val in zip(MindtPy.variable_list,
solve_data.initial_var_values):
if not nlp_var.fixed and not nlp_var.is_binary():
nlp_var.value = orig_val
feas_soln = nlpopt.solve(feas_nlp,
tee=config.solver_tee,
**nlp_args)
subprob_terminate_cond = feas_soln.solver.termination_condition
if subprob_terminate_cond in {tc.optimal, tc.locallyOptimal, tc.feasible}:
copy_var_list_values(
MindtPy.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
elif subprob_terminate_cond is tc.infeasible:
raise ValueError('Feasibility NLP infeasible. '
'This should never happen.')
elif subprob_terminate_cond is tc.maxIterations:
raise ValueError(
'Subsolver reached its maximum number of iterations without converging, '
'consider increasing the iterations limit of the subsolver or reviewing your formulation.'
)
else:
raise ValueError(
'MindtPy unable to handle feasibility NLP termination condition '
'of {}'.format(subprob_terminate_cond))
var_values = [v.value for v in MindtPy.variable_list]
duals = [0 for _ in MindtPy.constraint_list]
for i, c in enumerate(MindtPy.constraint_list):
rhs = c.upper if c.has_ub() else c.lower
c_geq = -1 if c.has_ub() else 1
duals[i] = c_geq * max(0, c_geq * (rhs - value(c.body)))
if value(MindtPy.MindtPy_feas_obj.expr) <= config.zero_tolerance:
config.logger.warning(
"The objective value %.4E of feasibility problem is less than zero_tolerance. "
"This indicates that the nlp subproblem is feasible, although it is found infeasible in the previous step. "
"Check the nlp solver output" %
value(MindtPy.MindtPy_feas_obj.expr))
return feas_nlp, feas_soln
def solve_OA_master(solve_data, config):
solve_data.mip_iter += 1
m = solve_data.mip.clone()
MindtPy = m.MindtPy_utils
config.logger.info('MIP %s: Solve master problem.' %
(solve_data.mip_iter, ))
# Set up MILP
for c in MindtPy.constraint_list:
if c.body.polynomial_degree() not in (1, 0):
c.deactivate()
MindtPy.MindtPy_linear_cuts.activate()
main_objective = next(m.component_data_objects(Objective, active=True))
main_objective.deactivate()
sign_adjust = 1 if main_objective.sense == minimize else -1
MindtPy.MindtPy_penalty_expr = Expression(
expr=sign_adjust * config.OA_penalty_factor *
sum(v for v in MindtPy.MindtPy_linear_cuts.slack_vars[...]))
MindtPy.MindtPy_oa_obj = Objective(expr=main_objective.expr +
MindtPy.MindtPy_penalty_expr,
sense=main_objective.sense)
# Deactivate extraneous IMPORT/EXPORT suffixes
getattr(m, 'ipopt_zL_out', _DoNothing()).deactivate()
getattr(m, 'ipopt_zU_out', _DoNothing()).deactivate()
# m.pprint() #print oa master problem for debugging
with SuppressInfeasibleWarning():
results = SolverFactory(config.mip_solver).solve(
m, **config.mip_solver_args)
master_terminate_cond = results.solver.termination_condition
if master_terminate_cond is tc.infeasibleOrUnbounded:
# Linear solvers will sometimes tell me that it's infeasible or
# unbounded during presolve, but fails to distinguish. We need to
# resolve with a solver option flag on.
results, master_terminate_cond = distinguish_mip_infeasible_or_unbounded(
m, config)
# Process master problem result
if master_terminate_cond is tc.optimal:
# proceed. Just need integer values
copy_var_list_values(
m.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
if main_objective.sense == minimize:
solve_data.LB = max(value(MindtPy.MindtPy_oa_obj.expr),
solve_data.LB)
solve_data.LB_progress.append(solve_data.LB)
else:
solve_data.UB = min(value(MindtPy.MindtPy_oa_obj.expr),
solve_data.UB)
solve_data.UB_progress.append(solve_data.UB)
config.logger.info(
'MIP %s: OBJ: %s LB: %s UB: %s' %
(solve_data.mip_iter, value(
MindtPy.MindtPy_oa_obj.expr), solve_data.LB, solve_data.UB))
elif master_terminate_cond is tc.infeasible:
config.logger.info(
'MILP master problem is infeasible. '
'Problem may have no more feasible binary combinations.')
if solve_data.mip_iter == 1:
config.logger.info(
'MindtPy initialization may have generated poor '
'quality cuts.')
elif master_terminate_cond is tc.maxTimeLimit:
# TODO check that status is actually ok and everything is feasible
config.logger.info('Unable to optimize MILP master problem '
'within time limit. '
'Using current solver feasible solution.')
copy_var_list_values(
m.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
if MindtPy.obj.sense == minimize:
solve_data.LB = max(value(MindtPy.obj.expr), solve_data.LB)
solve_data.LB_progress.append(solve_data.LB)
else:
solve_data.UB = min(value(MindtPy.obj.expr), solve_data.UB)
solve_data.UB_progress.append(solve_data.UB)
config.logger.info('MIP %s: OBJ: %s LB: %s UB: %s' %
(solve_data.mip_iter, value(MindtPy.obj.expr),
solve_data.LB, solve_data.UB))
elif (master_terminate_cond is tc.other
and results.solution.status is SolutionStatus.feasible):
# load the solution and suppress the warning message by setting
# solver status to ok.
config.logger.info('MILP solver reported feasible solution, '
'but not guaranteed to be optimal.')
copy_var_list_values(
m.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
if MindtPy.obj.sense == minimize:
solve_data.LB = max(value(MindtPy.MindtPy_oa_obj.expr),
solve_data.LB)
solve_data.LB_progress.append(solve_data.LB)
else:
solve_data.UB = min(value(MindtPy.MindtPy_oa_obj.expr),
solve_data.UB)
solve_data.UB_progress.append(solve_data.UB)
config.logger.info(
'MIP %s: OBJ: %s LB: %s UB: %s' %
(solve_data.mip_iter, value(
MindtPy.MindtPy_oa_obj.expr), solve_data.LB, solve_data.UB))
elif master_terminate_cond is tc.infeasible:
config.logger.info('MILP master problem is infeasible. '
'Problem may have no more feasible '
'binary configurations.')
if solve_data.mip_iter == 1:
config.logger.warn(
'MindtPy initialization may have generated poor '
'quality cuts.')
# set optimistic bound to infinity
if main_objective.sense == minimize:
solve_data.LB = float('inf')
solve_data.LB_progress.append(solve_data.UB)
else:
solve_data.UB = float('-inf')
solve_data.UB_progress.append(solve_data.UB)
elif master_terminate_cond is tc.unbounded:
# Solution is unbounded. Add an arbitrary bound to the objective and resolve.
# This occurs when the objective is nonlinear. The nonlinear objective is moved
# to the constraints, and deactivated for the linear master problem.
config.logger.warning(
'Master MILP was unbounded. '
'Resolving with arbitrary bound values of (-{0:.10g}, {0:.10g}) on the objective. '
'You can change this bound with the option obj_bound.'.format(
config.obj_bound))
main_objective = next(m.component_data_objects(Objective, active=True))
MindtPy.objective_bound = Constraint(expr=(-config.obj_bound,
main_objective.expr,
config.obj_bound))
with SuppressInfeasibleWarning():
results = SolverFactory(config.mip_solver).solve(
m, **config.mip_solver_args)
else:
raise ValueError(
'MindtPy unable to handle MILP master termination condition '
'of %s. Solver message: %s' %
(master_terminate_cond, results.solver.message))
# Call the MILP post-solve callback
config.call_after_master_solve(m, solve_data)
def solve_feasibility_subproblem(solve_data, config):
"""
Solves a feasibility NLP if the fixed_nlp problem is infeasible
Parameters
----------
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
Returns
-------
feas_subproblem: Pyomo model
feasibility NLP from the model
feas_soln: Pyomo results object
result from solving the feasibility NLP
"""
feas_subproblem = solve_data.working_model.clone()
add_feas_slacks(feas_subproblem, config)
MindtPy = feas_subproblem.MindtPy_utils
if MindtPy.find_component('objective_value') is not None:
MindtPy.objective_value.value = 0
next(feas_subproblem.component_data_objects(Objective,
active=True)).deactivate()
for constr in feas_subproblem.MindtPy_utils.nonlinear_constraint_list:
constr.deactivate()
MindtPy.feas_opt.activate()
if config.feasibility_norm == 'L1':
MindtPy.feas_obj = Objective(expr=sum(
s for s in MindtPy.feas_opt.slack_var[...]),
sense=minimize)
elif config.feasibility_norm == 'L2':
MindtPy.feas_obj = Objective(expr=sum(
s * s for s in MindtPy.feas_opt.slack_var[...]),
sense=minimize)
else:
MindtPy.feas_obj = Objective(expr=MindtPy.feas_opt.slack_var,
sense=minimize)
TransformationFactory('core.fix_integer_vars').apply_to(feas_subproblem)
nlpopt = SolverFactory(config.nlp_solver)
nlp_args = dict(config.nlp_solver_args)
set_solver_options(nlpopt, solve_data, config, solver_type='nlp')
with SuppressInfeasibleWarning():
try:
with time_code(solve_data.timing, 'feasibility subproblem'):
feas_soln = nlpopt.solve(feas_subproblem,
tee=config.nlp_solver_tee,
**nlp_args)
except (ValueError, OverflowError) as error:
for nlp_var, orig_val in zip(MindtPy.variable_list,
solve_data.initial_var_values):
if not nlp_var.fixed and not nlp_var.is_binary():
nlp_var.value = orig_val
with time_code(solve_data.timing, 'feasibility subproblem'):
feas_soln = nlpopt.solve(feas_subproblem,
tee=config.nlp_solver_tee,
**nlp_args)
subprob_terminate_cond = feas_soln.solver.termination_condition
if subprob_terminate_cond in {tc.optimal, tc.locallyOptimal, tc.feasible}:
copy_var_list_values(
MindtPy.variable_list,
solve_data.working_model.MindtPy_utils.variable_list, config)
elif subprob_terminate_cond in {tc.infeasible, tc.noSolution}:
config.logger.error('Feasibility subproblem infeasible. '
'This should never happen.')
solve_data.should_terminate = True
solve_data.results.solver.status = SolverStatus.error
return feas_subproblem, feas_soln
elif subprob_terminate_cond is tc.maxIterations:
config.logger.error(
'Subsolver reached its maximum number of iterations without converging, '
'consider increasing the iterations limit of the subsolver or reviewing your formulation.'
)
solve_data.should_terminate = True
solve_data.results.solver.status = SolverStatus.error
return feas_subproblem, feas_soln
else:
config.error(
'MindtPy unable to handle feasibility subproblem termination condition '
'of {}'.format(subprob_terminate_cond))
solve_data.should_terminate = True
solve_data.results.solver.status = SolverStatus.error
return feas_subproblem, feas_soln
if value(MindtPy.feas_obj.expr) <= config.zero_tolerance:
config.logger.warning(
'The objective value %.4E of feasibility problem is less than zero_tolerance. '
'This indicates that the nlp subproblem is feasible, although it is found infeasible in the previous step. '
'Check the nlp solver output' % value(MindtPy.feas_obj.expr))
return feas_subproblem, feas_soln
def solve_NLP(nlp_model, solve_data, config):
"""Solve the NLP subproblem."""
config.logger.info('Solving nonlinear subproblem for '
'fixed binaries and logical realizations.')
# Error checking for unfixed discrete variables
unfixed_discrete_vars = detect_unfixed_discrete_vars(nlp_model)
assert len(unfixed_discrete_vars) == 0, \
"Unfixed discrete variables exist on the NLP subproblem: {0}".format(
list(v.name for v in unfixed_discrete_vars))
GDPopt = nlp_model.GDPopt_utils
if config.subproblem_presolve:
preprocess_subproblem(nlp_model, config)
initialize_subproblem(nlp_model, solve_data)
# Callback immediately before solving NLP subproblem
config.call_before_subproblem_solve(nlp_model, solve_data)
nlp_solver = SolverFactory(config.nlp_solver)
if not nlp_solver.available():
raise RuntimeError("NLP solver %s is not available." %
config.nlp_solver)
with SuppressInfeasibleWarning():
results = nlp_solver.solve(nlp_model, **config.nlp_solver_args)
nlp_result = SubproblemResult()
nlp_result.feasible = True
nlp_result.var_values = list(v.value for v in GDPopt.variable_list)
nlp_result.pyomo_results = results
nlp_result.dual_values = list(
nlp_model.dual.get(c, None) for c in GDPopt.constraint_list)
subprob_terminate_cond = results.solver.termination_condition
if (subprob_terminate_cond is tc.optimal
or subprob_terminate_cond is tc.locallyOptimal
or subprob_terminate_cond is tc.feasible):
pass
elif subprob_terminate_cond is tc.infeasible:
config.logger.info('NLP subproblem was infeasible.')
nlp_result.feasible = False
elif subprob_terminate_cond is tc.maxIterations:
# TODO try something else? Reinitialize with different initial
# value?
config.logger.info(
'NLP subproblem failed to converge within iteration limit.')
if is_feasible(nlp_model, config):
config.logger.info(
'NLP solution is still feasible. '
'Using potentially suboptimal feasible solution.')
else:
nlp_result.feasible = False
elif subprob_terminate_cond is tc.internalSolverError:
# Possible that IPOPT had a restoration failure
config.logger.info("NLP solver had an internal failure: %s" %
results.solver.message)
nlp_result.feasible = False
else:
raise ValueError('GDPopt unable to handle NLP subproblem termination '
'condition of %s. Results: %s' %
(subprob_terminate_cond, results))
# Call the NLP post-solve callback
config.call_after_subproblem_solve(nlp_model, solve_data)
# if feasible, call the NLP post-feasible callback
if nlp_result.feasible:
config.call_after_subproblem_feasible(nlp_model, solve_data)
return nlp_result
def solve_NLP(nlp_model, solve_data, config):
"""Solve the NLP subproblem."""
config.logger.info('Solving nonlinear subproblem for '
'fixed binaries and logical realizations.')
unfixed_discrete_vars = detect_unfixed_discrete_vars(nlp_model)
if unfixed_discrete_vars:
discrete_var_names = list(v.name for v in unfixed_discrete_vars)
config.logger.warning(
"Unfixed discrete variables exist on the NLP subproblem: %s" %
(discrete_var_names, ))
GDPopt = nlp_model.GDPopt_utils
preprocessing_transformations = [
# Propagate variable bounds
'contrib.propagate_eq_var_bounds',
# Detect fixed variables
'contrib.detect_fixed_vars',
# Propagate fixed variables
'contrib.propagate_fixed_vars',
# Remove zero terms in linear expressions
'contrib.remove_zero_terms',
# Remove terms in equal to zero summations
'contrib.propagate_zero_sum',
# Transform bound constraints
'contrib.constraints_to_var_bounds',
# Detect fixed variables
'contrib.detect_fixed_vars',
# Remove terms in equal to zero summations
'contrib.propagate_zero_sum',
# Remove trivial constraints
'contrib.deactivate_trivial_constraints'
]
for xfrm in preprocessing_transformations:
TransformationFactory(xfrm).apply_to(nlp_model)
initialize_NLP(nlp_model, solve_data)
# Callback immediately before solving NLP subproblem
config.call_before_subproblem_solve(nlp_model, solve_data)
nlp_solver = SolverFactory(config.nlp_solver)
if not nlp_solver.available():
raise RuntimeError("NLP solver %s is not available." %
config.nlp_solver)
with SuppressInfeasibleWarning():
results = nlp_solver.solve(nlp_model, **config.nlp_solver_args)
nlp_result = SubproblemResult()
nlp_result.feasible = True
nlp_result.var_values = list(v.value for v in GDPopt.working_var_list)
nlp_result.pyomo_results = results
nlp_result.dual_values = list(
nlp_model.dual.get(c, None) for c in GDPopt.working_constraints_list)
subprob_terminate_cond = results.solver.termination_condition
if subprob_terminate_cond is tc.optimal:
pass
elif subprob_terminate_cond is tc.infeasible:
config.logger.info('NLP subproblem was locally infeasible.')
nlp_result.feasible = False
elif subprob_terminate_cond is tc.maxIterations:
# TODO try something else? Reinitialize with different initial
# value?
config.logger.info(
'NLP subproblem failed to converge within iteration limit.')
if is_feasible(nlp_model, config):
config.logger.info(
'NLP solution is still feasible. '
'Using potentially suboptimal feasible solution.')
else:
nlp_result.feasible = False
elif subprob_terminate_cond is tc.internalSolverError:
# Possible that IPOPT had a restoration failture
config.logger.info("NLP solver had an internal failure: %s" %
results.solver.message)
nlp_result.feasible = False
else:
raise ValueError('GDPopt unable to handle NLP subproblem termination '
'condition of %s. Results: %s' %
(subprob_terminate_cond, results))
# Call the NLP post-solve callback
config.call_after_subproblem_solve(nlp_model, solve_data)
# if feasible, call the NLP post-feasible callback
if nlp_result.feasible:
config.call_after_subproblem_feasible(nlp_model, solve_data)
return nlp_result
def solve_NLP_subproblem(solve_data, config):
""" Solves fixed NLP with fixed working model binaries
Sets up local working model `fixed_nlp`
Fixes binaries
Sets continuous variables to initial var values
Precomputes dual values
Deactivates trivial constraints
Solves NLP model
Returns the fixed-NLP model and the solver results
"""
fixed_nlp = solve_data.working_model.clone()
MindtPy = fixed_nlp.MindtPy_utils
solve_data.nlp_iter += 1
config.logger.info('NLP %s: Solve subproblem for fixed binaries.' %
(solve_data.nlp_iter, ))
# Set up NLP
TransformationFactory('core.fix_integer_vars').apply_to(fixed_nlp)
MindtPy.MindtPy_linear_cuts.deactivate()
fixed_nlp.tmp_duals = ComponentMap()
# tmp_duals are the value of the dual variables stored before using deactivate trivial contraints
# The values of the duals are computed as follows: (Complementary Slackness)
#
# | constraint | c_geq | status at x1 | tmp_dual (violation) |
# |------------|-------|--------------|----------------------|
# | g(x) <= b | -1 | g(x1) <= b | 0 |
# | g(x) <= b | -1 | g(x1) > b | g(x1) - b |
# | g(x) >= b | +1 | g(x1) >= b | 0 |
# | g(x) >= b | +1 | g(x1) < b | b - g(x1) |
evaluation_error = False
for c in fixed_nlp.component_data_objects(ctype=Constraint,
active=True,
descend_into=True):
# We prefer to include the upper bound as the right hand side since we are
# considering c by default a (hopefully) convex function, which would make
# c >= lb a nonconvex inequality which we wouldn't like to add linearizations
# if we don't have to
rhs = c.upper if c.has_ub() else c.lower
c_geq = -1 if c.has_ub() else 1
# c_leq = 1 if c.has_ub else -1
try:
fixed_nlp.tmp_duals[c] = c_geq * max(0,
c_geq * (rhs - value(c.body)))
except (ValueError, OverflowError) as error:
fixed_nlp.tmp_duals[c] = None
evaluation_error = True
if evaluation_error:
for nlp_var, orig_val in zip(MindtPy.variable_list,
solve_data.initial_var_values):
if not nlp_var.fixed and not nlp_var.is_binary():
nlp_var.value = orig_val
# fixed_nlp.tmp_duals[c] = c_leq * max(
# 0, c_leq*(value(c.body) - rhs))
# TODO: change logic to c_leq based on benchmarking
TransformationFactory('contrib.deactivate_trivial_constraints')\
.apply_to(fixed_nlp, tmp=True, ignore_infeasible=True)
# Solve the NLP
with SuppressInfeasibleWarning():
results = SolverFactory(config.nlp_solver).solve(
fixed_nlp, **config.nlp_solver_args)
return fixed_nlp, results
def solve_linear_GDP(linear_GDP_model, solve_data, config):
"""Solves the linear GDP model and attempts to resolve solution issues."""
m = linear_GDP_model
GDPopt = m.GDPopt_utils
# Transform disjunctions
TransformationFactory('gdp.bigm').apply_to(m)
preprocessing_transformations = [
# Propagate variable bounds
'contrib.propagate_eq_var_bounds',
# Detect fixed variables
'contrib.detect_fixed_vars',
# Propagate fixed variables
'contrib.propagate_fixed_vars',
# Remove zero terms in linear expressions
'contrib.remove_zero_terms',
# Remove terms in equal to zero summations
'contrib.propagate_zero_sum',
# Transform bound constraints
'contrib.constraints_to_var_bounds',
# Detect fixed variables
'contrib.detect_fixed_vars',
# Remove terms in equal to zero summations
'contrib.propagate_zero_sum',
# Remove trivial constraints
'contrib.deactivate_trivial_constraints',
]
if config.mip_presolve:
for xfrm in preprocessing_transformations:
TransformationFactory(xfrm).apply_to(m)
# Deactivate extraneous IMPORT/EXPORT suffixes
getattr(m, 'ipopt_zL_out', _DoNothing()).deactivate()
getattr(m, 'ipopt_zU_out', _DoNothing()).deactivate()
# Create solver, check availability
if not SolverFactory(config.mip_solver).available():
raise RuntimeError(
"MIP solver %s is not available." % config.mip_solver)
# Callback immediately before solving NLP subproblem
config.call_before_master_solve(m, solve_data)
# We use LoggingIntercept in order to suppress the stupid "Loading a
# SolverResults object with a warning status" warning message.
with SuppressInfeasibleWarning():
results = SolverFactory(config.mip_solver).solve(
m, **config.mip_solver_args)
terminate_cond = results.solver.termination_condition
if terminate_cond is tc.infeasibleOrUnbounded:
# Linear solvers will sometimes tell me that it's infeasible or
# unbounded during presolve, but fails to distinguish. We need to
# resolve with a solver option flag on.
results, terminate_cond = distinguish_mip_infeasible_or_unbounded(
m, config)
# Build and return results object
mip_result = MasterProblemResult()
mip_result.feasible = True
mip_result.var_values = list(v.value for v in GDPopt.working_var_list)
mip_result.pyomo_results = results
mip_result.disjunct_values = list(
disj.indicator_var.value for disj in GDPopt.working_disjuncts_list)
if terminate_cond is tc.optimal or terminate_cond is tc.locallyOptimal:
pass
elif terminate_cond is tc.infeasible:
config.logger.info(
'Linear GDP is now infeasible. '
'GDPopt has finished exploring feasible discrete configurations.')
mip_result.feasible = False
elif terminate_cond is tc.maxTimeLimit:
# TODO check that status is actually ok and everything is feasible
config.logger.info(
'Unable to optimize linear GDP problem within time limit. '
'Using current solver feasible solution.')
elif (terminate_cond is tc.other and
results.solution.status is SolutionStatus.feasible):
# load the solution and suppress the warning message by setting
# solver status to ok.
config.logger.info(
'Linear GDP solver reported feasible solution, '
'but not guaranteed to be optimal.')
else:
raise ValueError(
'GDPopt unable to handle linear GDP '
'termination condition '
'of %s. Solver message: %s' %
(terminate_cond, results.solver.message))
return mip_result
def solve_fp_subproblem(solve_data, config):
"""Solves the feasibility pump NLP subproblem.
This function sets up the 'fp_nlp' by relax integer variables.
precomputes dual values, deactivates trivial constraints, and then solves NLP model.
Parameters
----------
solve_data : MindtPySolveData
Data container that holds solve-instance data.
config : ConfigBlock
The specific configurations for MindtPy.
Returns
-------
fp_nlp : Pyomo model
Fixed-NLP from the model.
results : SolverResults
Results from solving the fixed-NLP subproblem.
"""
fp_nlp = solve_data.working_model.clone()
MindtPy = fp_nlp.MindtPy_utils
# Set up NLP
fp_nlp.MindtPy_utils.objective_list[-1].deactivate()
if solve_data.objective_sense == minimize:
fp_nlp.improving_objective_cut = Constraint(
expr=sum(fp_nlp.MindtPy_utils.objective_value[:]) <= solve_data.UB)
else:
fp_nlp.improving_objective_cut = Constraint(
expr=sum(fp_nlp.MindtPy_utils.objective_value[:]) >= solve_data.LB)
# Add norm_constraint, which guarantees the monotonicity of the norm objective value sequence of all iterations
# Ref: Paper 'A storm of feasibility pumps for nonconvex MINLP' https://doi.org/10.1007/s10107-012-0608-x
# the norm type is consistant with the norm obj of the FP-main problem.
if config.fp_norm_constraint:
generate_norm_constraint(fp_nlp, solve_data, config)
MindtPy.fp_nlp_obj = generate_norm2sq_objective_function(
fp_nlp, solve_data.mip, discrete_only=config.fp_discrete_only)
MindtPy.cuts.deactivate()
TransformationFactory('core.relax_integer_vars').apply_to(fp_nlp)
try:
TransformationFactory(
'contrib.deactivate_trivial_constraints').apply_to(
fp_nlp,
tmp=True,
ignore_infeasible=False,
tolerance=config.constraint_tolerance)
except ValueError:
config.logger.warning(
'infeasibility detected in deactivate_trivial_constraints')
results = SolverResults()
results.solver.termination_condition = tc.infeasible
return fp_nlp, results
# Solve the NLP
nlpopt = SolverFactory(config.nlp_solver)
nlp_args = dict(config.nlp_solver_args)
set_solver_options(nlpopt, solve_data, config, solver_type='nlp')
with SuppressInfeasibleWarning():
with time_code(solve_data.timing, 'fp subproblem'):
results = nlpopt.solve(fp_nlp,
tee=config.nlp_solver_tee,
**nlp_args)
return fp_nlp, results
def solve_fp_subproblem(solve_data, config):
"""
Solves the feasibility pump NLP
This function sets up the 'fp_nlp' by relax integer variables.
precomputes dual values, deactivates trivial constraints, and then solves NLP model.
Parameters
----------
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
Returns
-------
fp_nlp: Pyomo model
Fixed-NLP from the model
results: Pyomo results object
result from solving the Fixed-NLP
"""
fp_nlp = solve_data.working_model.clone()
MindtPy = fp_nlp.MindtPy_utils
config.logger.info('FP-NLP %s: Solve feasibility pump NLP subproblem.'
% (solve_data.fp_iter,))
# Set up NLP
fp_nlp.MindtPy_utils.objective_list[-1].deactivate()
if solve_data.objective_sense == minimize:
fp_nlp.improving_objective_cut = Constraint(
expr=fp_nlp.MindtPy_utils.objective_value <= solve_data.UB)
else:
fp_nlp.improving_objective_cut = Constraint(
expr=fp_nlp.MindtPy_utils.objective_value >= solve_data.LB)
# Add norm_constraint, which guarantees the monotonicity of the norm objective value sequence of all iterations
# Ref: Paper 'A storm of feasibility pumps for nonconvex MINLP'
# the norm type is consistant with the norm obj of the FP-main problem.
if config.fp_norm_constraint:
if config.fp_main_norm == 'L1':
# TODO: check if we can access the block defined in FP-main problem
generate_norm1_norm_constraint(
fp_nlp, solve_data.mip, config, discrete_only=True)
elif config.fp_main_norm == 'L2':
fp_nlp.norm_constraint = Constraint(expr=sum((nlp_var - mip_var.value)**2 - config.fp_norm_constraint_coef*(nlp_var.value - mip_var.value)**2
for nlp_var, mip_var in zip(fp_nlp.MindtPy_utils.discrete_variable_list, solve_data.mip.MindtPy_utils.discrete_variable_list)) <= 0)
elif config.fp_main_norm == 'L_infinity':
fp_nlp.norm_constraint = ConstraintList()
rhs = config.fp_norm_constraint_coef * max(nlp_var.value - mip_var.value for nlp_var, mip_var in zip(
fp_nlp.MindtPy_utils.discrete_variable_list, solve_data.mip.MindtPy_utils.discrete_variable_list))
for nlp_var, mip_var in zip(fp_nlp.MindtPy_utils.discrete_variable_list, solve_data.mip.MindtPy_utils.discrete_variable_list):
fp_nlp.norm_constraint.add(nlp_var - mip_var.value <= rhs)
MindtPy.fp_nlp_obj = generate_norm2sq_objective_function(
fp_nlp, solve_data.mip, discrete_only=config.fp_discrete_only)
MindtPy.cuts.deactivate()
TransformationFactory('core.relax_integer_vars').apply_to(fp_nlp)
try:
TransformationFactory('contrib.deactivate_trivial_constraints').apply_to(
fp_nlp, tmp=True, ignore_infeasible=False, tolerance=config.constraint_tolerance)
except ValueError:
config.logger.warning(
'infeasibility detected in deactivate_trivial_constraints')
results = SolverResults()
results.solver.termination_condition = tc.infeasible
return fp_nlp, results
# Solve the NLP
nlpopt = SolverFactory(config.nlp_solver)
nlp_args = dict(config.nlp_solver_args)
set_solver_options(nlpopt, solve_data, config, solver_type='nlp')
with SuppressInfeasibleWarning():
with time_code(solve_data.timing, 'fp subproblem'):
results = nlpopt.solve(
fp_nlp, tee=config.nlp_solver_tee, **nlp_args)
return fp_nlp, results
def solve_MINLP(model, solve_data, config):
"""Solve the MINLP subproblem."""
config.logger.info(
"Solving MINLP subproblem for fixed logical realizations.")
GDPopt = model.GDPopt_utils
initialize_subproblem(model, solve_data)
# Callback immediately before solving MINLP subproblem
config.call_before_subproblem_solve(model, solve_data)
minlp_solver = SolverFactory(config.minlp_solver)
if not minlp_solver.available():
raise RuntimeError("MINLP solver %s is not available." %
config.minlp_solver)
with SuppressInfeasibleWarning():
results = minlp_solver.solve(model, **config.minlp_solver_args)
subprob_result = SubproblemResult()
subprob_result.feasible = True
subprob_result.var_values = list(v.value for v in GDPopt.variable_list)
subprob_result.pyomo_results = results
subprob_result.dual_values = list(
model.dual.get(c, None) for c in GDPopt.constraint_list)
term_cond = results.solver.termination_condition
if any(term_cond == cond
for cond in (tc.optimal, tc.locallyOptimal, tc.feasible)):
pass
elif term_cond == tc.infeasible:
config.logger.info('MINLP subproblem was infeasible.')
subprob_result.feasible = False
elif term_cond == tc.maxIterations:
# TODO try something else? Reinitialize with different initial
# value?
config.logger.info(
'MINLP subproblem failed to converge within iteration limit.')
if is_feasible(model, config):
config.logger.info(
'MINLP solution is still feasible. '
'Using potentially suboptimal feasible solution.')
else:
subprob_result.feasible = False
elif term_cond == tc.intermediateNonInteger:
config.logger.info(
"MINLP solver could not find feasible integer solution: %s" %
results.solver.message)
subprob_result.feasible = False
else:
raise ValueError(
'GDPopt unable to handle MINLP subproblem termination '
'condition of %s. Results: %s' % (term_cond, results))
# Call the subproblem post-solve callback
config.call_after_subproblem_solve(model, solve_data)
# if feasible, call the subproblem post-feasible callback
if subprob_result.feasible:
config.call_after_subproblem_feasible(model, solve_data)
return subprob_result
def _solve_rnGDP_subproblem(model, solve_data):
config = solve_data.config
subproblem = TransformationFactory('gdp.bigm').create_using(model)
obj_sense_correction = solve_data.objective_sense != minimize
try:
with SuppressInfeasibleWarning():
try:
fbbt(subproblem, integer_tol=config.integer_tolerance)
except InfeasibleConstraintException:
copy_var_list_values( # copy variable values, even if errored
from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('inf'), float('inf')
minlp_args = dict(config.minlp_solver_args)
if config.minlp_solver == 'gams':
elapsed = get_main_elapsed_time(solve_data.timing)
remaining = max(config.time_limit - elapsed, 1)
minlp_args['add_options'] = minlp_args.get('add_options', [])
minlp_args['add_options'].append('option reslim=%s;' %
remaining)
result = SolverFactory(config.minlp_solver).solve(
subproblem, **minlp_args)
except RuntimeError as e:
config.logger.warning(
"Solver encountered RuntimeError. Treating as infeasible. "
"Msg: %s\n%s" % (str(e), traceback.format_exc()))
copy_var_list_values( # copy variable values, even if errored
from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('inf'), float('inf')
term_cond = result.solver.termination_condition
if term_cond == tc.optimal:
assert result.solver.status is SolverStatus.ok
lb = result.problem.lower_bound if not obj_sense_correction else -result.problem.upper_bound
ub = result.problem.upper_bound if not obj_sense_correction else -result.problem.lower_bound
copy_var_list_values(
from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
)
return lb, ub
elif term_cond == tc.locallyOptimal or term_cond == tc.feasible:
assert result.solver.status is SolverStatus.ok
lb = result.problem.lower_bound if not obj_sense_correction else -result.problem.upper_bound
ub = result.problem.upper_bound if not obj_sense_correction else -result.problem.lower_bound
# TODO handle LB absent
copy_var_list_values(
from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
)
return lb, ub
elif term_cond == tc.unbounded:
copy_var_list_values(from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('-inf'), float('-inf')
elif term_cond == tc.infeasible:
copy_var_list_values(from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('inf'), float('inf')
else:
config.logger.warning(
"Unknown termination condition of %s. Treating as infeasible." %
term_cond)
copy_var_list_values(from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('inf'), float('inf')
def solve_NLP(nlp_model, solve_data, config):
"""Solve the NLP subproblem."""
config.logger.info('Solving nonlinear subproblem for '
'fixed binaries and logical realizations.')
# Error checking for unfixed discrete variables
unfixed_discrete_vars = detect_unfixed_discrete_vars(nlp_model)
assert len(unfixed_discrete_vars) == 0, \
"Unfixed discrete variables exist on the NLP subproblem: {0}".format(
list(v.name for v in unfixed_discrete_vars))
GDPopt = nlp_model.GDPopt_utils
initialize_subproblem(nlp_model, solve_data)
# Callback immediately before solving NLP subproblem
config.call_before_subproblem_solve(nlp_model, solve_data)
nlp_solver = SolverFactory(config.nlp_solver)
if not nlp_solver.available():
raise RuntimeError("NLP solver %s is not available." %
config.nlp_solver)
with SuppressInfeasibleWarning():
try:
results = nlp_solver.solve(nlp_model, **config.nlp_solver_args)
except ValueError as err:
if 'Cannot load SolverResults object with bad status: error' in str(
err):
results = SolverResults()
results.solver.termination_condition = tc.error
results.solver.message = str(err)
else:
raise
nlp_result = SubproblemResult()
nlp_result.feasible = True
nlp_result.var_values = list(v.value for v in GDPopt.variable_list)
nlp_result.pyomo_results = results
nlp_result.dual_values = list(
nlp_model.dual.get(c, None) for c in GDPopt.constraint_list)
term_cond = results.solver.termination_condition
if any(term_cond == cond
for cond in (tc.optimal, tc.locallyOptimal, tc.feasible)):
pass
elif term_cond == tc.infeasible:
config.logger.info('NLP subproblem was infeasible.')
nlp_result.feasible = False
elif term_cond == tc.maxIterations:
# TODO try something else? Reinitialize with different initial
# value?
config.logger.info(
'NLP subproblem failed to converge within iteration limit.')
if is_feasible(nlp_model, config):
config.logger.info(
'NLP solution is still feasible. '
'Using potentially suboptimal feasible solution.')
else:
nlp_result.feasible = False
elif term_cond == tc.internalSolverError:
# Possible that IPOPT had a restoration failure
config.logger.info("NLP solver had an internal failure: %s" %
results.solver.message)
nlp_result.feasible = False
elif (term_cond == tc.other
and "Too few degrees of freedom" in str(results.solver.message)):
# Possible IPOPT degrees of freedom error
config.logger.info("IPOPT has too few degrees of freedom: %s" %
results.solver.message)
nlp_result.feasible = False
elif term_cond == tc.other:
config.logger.info(
"NLP solver had a termination condition of 'other': %s" %
results.solver.message)
nlp_result.feasible = False
elif term_cond == tc.error:
config.logger.info(
"NLP solver had a termination condition of 'error': %s" %
results.solver.message)
nlp_result.feasible = False
elif term_cond == tc.maxTimeLimit:
config.logger.info(
"NLP solver ran out of time. Assuming infeasible for now.")
nlp_result.feasible = False
else:
raise ValueError('GDPopt unable to handle NLP subproblem termination '
'condition of %s. Results: %s' % (term_cond, results))
# Call the NLP post-solve callback
config.call_after_subproblem_solve(nlp_model, solve_data)
# if feasible, call the NLP post-feasible callback
if nlp_result.feasible:
config.call_after_subproblem_feasible(nlp_model, solve_data)
return nlp_result
def _solve_local_rnGDP_subproblem(model, solve_data):
# TODO for now, return (LB, UB) = (-inf, inf) (for minimize)
config = solve_data.config
subproblem = TransformationFactory('gdp.bigm').create_using(model)
obj_sense_correction = solve_data.objective_sense != minimize
try:
with SuppressInfeasibleWarning():
result = SolverFactory(config.local_minlp_solver).solve(
subproblem, **config.local_minlp_solver_args)
except RuntimeError as e:
config.logger.warning(
"Solver encountered RuntimeError. Treating as infeasible. "
"Msg: %s\n%s" % (str(e), traceback.format_exc()))
copy_var_list_values( # copy variable values, even if errored
from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('-inf'), float('inf')
term_cond = result.solver.termination_condition
if term_cond == tc.optimal:
assert result.solver.status is SolverStatus.ok
lb = result.problem.lower_bound if not obj_sense_correction else -result.problem.upper_bound
ub = result.problem.upper_bound if not obj_sense_correction else -result.problem.lower_bound
copy_var_list_values(
from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
)
return float('-inf'), ub
elif term_cond == tc.locallyOptimal or term_cond == tc.feasible:
assert result.solver.status is SolverStatus.ok
lb = result.problem.lower_bound if not obj_sense_correction else -result.problem.upper_bound
ub = result.problem.upper_bound if not obj_sense_correction else -result.problem.lower_bound
# TODO handle LB absent
copy_var_list_values(
from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
)
return float('-inf'), ub
elif term_cond == tc.unbounded:
copy_var_list_values(from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('-inf'), float('-inf')
elif term_cond == tc.infeasible:
copy_var_list_values(from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('-inf'), float('inf')
else:
config.logger.warning(
"Unknown termination condition of %s. Treating as infeasible." %
term_cond)
copy_var_list_values(from_list=subproblem.GDPopt_utils.variable_list,
to_list=model.GDPopt_utils.variable_list,
config=config,
ignore_integrality=True)
return float('-inf'), float('inf')