def handle_subproblem_optimal(fixed_nlp,
solve_data,
config,
cb_opt=None,
fp=False):
"""This function copies the result of the NLP solver function ('solve_subproblem') to the working model, updates
the bounds, adds OA and no-good cuts, and then stores the new solution if it is the new best solution. This
function handles the result of the latest iteration of solving the NLP subproblem given an optimal solution.
Parameters
----------
fixed_nlp : Pyomo model
Integer-variable-fixed NLP model.
solve_data : MindtPySolveData
Data container that holds solve-instance data.
config : ConfigBlock
The specific configurations for MindtPy.
cb_opt : SolverFactory, optional
The gurobi_persistent solver, by default None.
fp : bool, optional
Whether it is in the loop of feasibility pump, by default False.
"""
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list,
config)
if config.calculate_dual:
for c in fixed_nlp.tmp_duals:
if fixed_nlp.dual.get(c, None) is None:
fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c]
dual_values = list(fixed_nlp.dual[c]
for c in fixed_nlp.MindtPy_utils.constraint_list)
else:
dual_values = None
main_objective = fixed_nlp.MindtPy_utils.objective_list[-1]
update_primal_bound(solve_data, value(main_objective.expr))
if solve_data.primal_bound_improved:
solve_data.best_solution_found = fixed_nlp.clone()
solve_data.best_solution_found_time = get_main_elapsed_time(
solve_data.timing)
if config.strategy == 'GOA':
solve_data.num_no_good_cuts_added.update({
solve_data.primal_bound:
len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts)
})
# add obj increasing constraint for fp
if fp:
solve_data.mip.MindtPy_utils.cuts.del_component(
'improving_objective_cut')
if solve_data.objective_sense == minimize:
solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint(
expr=sum(solve_data.mip.MindtPy_utils.objective_value[:])
<= solve_data.primal_bound - config.fp_cutoffdecr *
max(1, abs(solve_data.primal_bound)))
else:
solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint(
expr=sum(solve_data.mip.MindtPy_utils.objective_value[:])
>= solve_data.primal_bound + config.fp_cutoffdecr *
max(1, abs(solve_data.primal_bound)))
# Add the linear cut
if config.strategy == 'OA' or fp:
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
add_oa_cuts(solve_data.mip, dual_values, solve_data, config, cb_opt)
elif config.strategy == 'GOA':
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
add_affine_cuts(solve_data, config)
# elif config.strategy == 'PSC':
# # !!THIS SEEMS LIKE A BUG!! - mrmundt #
# add_psc_cut(solve_data, config)
# elif config.strategy == 'GBD':
# # !!THIS SEEMS LIKE A BUG!! - mrmundt #
# add_gbd_cut(solve_data, config)
var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list)
if config.add_no_good_cuts:
add_no_good_cuts(var_values, solve_data, config)
config.call_after_subproblem_feasible(fixed_nlp, solve_data)
config.logger.info(
solve_data.fixed_nlp_log_formatter.format(
'*' if solve_data.primal_bound_improved else ' ',
solve_data.nlp_iter if not fp else solve_data.fp_iter, 'Fixed NLP',
value(main_objective.expr), solve_data.primal_bound,
solve_data.dual_bound, solve_data.rel_gap,
get_main_elapsed_time(solve_data.timing)))
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 handle_lazy_subproblem_optimal(self, fixed_nlp, solve_data, config,
opt):
"""
This function copies result to mip(explaination see below), updates bound, adds OA and no-good cuts,
stores best solution if new one is best
Parameters
----------
fixed_nlp: Pyomo model
Fixed-NLP from the model
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
opt: SolverFactory
the mip solver
"""
if config.calculate_dual:
for c in fixed_nlp.tmp_duals:
if fixed_nlp.dual.get(c, None) is None:
fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c]
dual_values = list(
fixed_nlp.dual[c]
for c in fixed_nlp.MindtPy_utils.constraint_list)
else:
dual_values = None
main_objective = fixed_nlp.MindtPy_utils.objective_list[-1]
if solve_data.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(
'Fixed-NLP {}: OBJ: {} LB: {} UB: {} TIME: {}'.format(
solve_data.nlp_iter, value(main_objective.expr), solve_data.LB,
solve_data.UB,
round(get_main_elapsed_time(solve_data.timing), 2)))
if solve_data.solution_improved:
solve_data.best_solution_found = fixed_nlp.clone()
solve_data.best_solution_found_time = get_main_elapsed_time(
solve_data.timing)
if config.add_no_good_cuts or config.use_tabu_list:
if solve_data.results.problem.sense == ProblemSense.minimize:
solve_data.stored_bound.update(
{solve_data.UB: solve_data.LB})
else:
solve_data.stored_bound.update(
{solve_data.LB: solve_data.UB})
# In OA algorithm, OA cuts are generated based on the solution of the subproblem
# We need to first copy the value of variables from the subproblem and then add cuts
# since value(constr.body), value(jacs[constr][var]), value(var) are used in self.add_lazy_oa_cuts()
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
if config.strategy == 'OA':
self.add_lazy_oa_cuts(solve_data.mip, dual_values, solve_data,
config, opt)
if config.add_regularization is not None:
add_oa_cuts(solve_data.mip, dual_values, solve_data, config)
elif config.strategy == 'GOA':
self.add_lazy_affine_cuts(solve_data, config, opt)
if config.add_no_good_cuts:
var_values = list(v.value
for v in fixed_nlp.MindtPy_utils.variable_list)
self.add_lazy_no_good_cuts(var_values, solve_data, config, opt)
def LazyOACallback_gurobi(cb_m, cb_opt, cb_where, solve_data, config):
"""
This is a GUROBI callback function defined for LP/NLP based B&B algorithm.
Parameters
----------
cb_m: Pyomo model
the MIP main problem
cb_opt: SolverFactory
the gurobi_persistent solver
cb_where: int
an enum member of gurobipy.GRB.Callback
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
"""
if cb_where == gurobipy.GRB.Callback.MIPSOL:
# gurobipy.GRB.Callback.MIPSOL means that an integer solution is found during the branch and bound process
if solve_data.should_terminate:
cb_opt._solver_model.terminate()
return
cb_opt.cbGetSolution(vars=cb_m.MindtPy_utils.variable_list)
handle_lazy_main_feasible_solution_gurobi(cb_m, cb_opt, solve_data,
config)
if config.add_cuts_at_incumbent:
if config.strategy == 'OA':
add_oa_cuts(solve_data.mip, None, solve_data, config, cb_opt)
# # regularization is activated after the first feasible solution is found.
if config.add_regularization is not None and solve_data.best_solution_found is not None:
# the main problem might be unbounded, regularization is activated only when a valid bound is provided.
if not solve_data.bound_improved and not solve_data.solution_improved:
config.logger.info(
'the bound and the best found solution have neither been improved.'
'We will skip solving the regularization problem and the Fixed-NLP subproblem'
)
solve_data.solution_improved = False
return
if ((solve_data.objective_sense == minimize
and solve_data.LB != float('-inf'))
or (solve_data.objective_sense == maximize
and solve_data.UB != float('inf'))):
main_mip, main_mip_results = solve_main(
solve_data, config, regularization_problem=True)
handle_regularization_main_tc(main_mip, main_mip_results,
solve_data, config)
if solve_data.LB + config.bound_tolerance >= solve_data.UB:
config.logger.info('MindtPy exiting on bound convergence. '
'LB: {} + (tol {}) >= UB: {}\n'.format(
solve_data.LB, config.bound_tolerance,
solve_data.UB))
solve_data.results.solver.termination_condition = tc.optimal
cb_opt._solver_model.terminate()
return
# # check if the same integer combination is obtained.
solve_data.curr_int_sol = get_integer_solution(
solve_data.working_model, string_zero=True)
if solve_data.curr_int_sol in set(solve_data.integer_list):
config.logger.info(
'This integer combination has been explored. '
'We will skip solving the Fixed-NLP subproblem.')
solve_data.solution_improved = False
if config.strategy == 'GOA':
if config.add_no_good_cuts:
var_values = list(
v.value for v in
solve_data.working_model.MindtPy_utils.variable_list)
add_no_good_cuts(var_values, solve_data, config)
return
elif config.strategy == 'OA':
return
else:
solve_data.integer_list.append(solve_data.curr_int_sol)
# solve subproblem
# The constraint linearization happens in the handlers
fixed_nlp, fixed_nlp_result = solve_subproblem(solve_data, config)
handle_nlp_subproblem_tc(fixed_nlp, fixed_nlp_result, solve_data,
config, cb_opt)
def handle_subproblem_optimal(fixed_nlp, solve_data, config, fp=False):
"""
This function copies the result of the NLP solver function ('solve_subproblem') to the working model, updates
the bounds, adds OA and no-good cuts, and then stores the new solution if it is the new best solution. This
function handles the result of the latest iteration of solving the NLP subproblem given an optimal solution.
Parameters
----------
fixed_nlp: Pyomo model
Fixed-NLP from the model
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
"""
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list,
config)
if config.calculate_dual:
for c in fixed_nlp.tmp_duals:
if fixed_nlp.dual.get(c, None) is None:
fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c]
dual_values = list(fixed_nlp.dual[c]
for c in fixed_nlp.MindtPy_utils.constraint_list)
else:
dual_values = None
main_objective = fixed_nlp.MindtPy_utils.objective_list[-1]
if solve_data.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(
'Fixed-NLP {}: OBJ: {} LB: {} UB: {} TIME: {}s'.format(
solve_data.nlp_iter if not fp else solve_data.fp_iter,
value(main_objective.expr), solve_data.LB, solve_data.UB,
round(get_main_elapsed_time(solve_data.timing), 2)))
if solve_data.solution_improved:
solve_data.best_solution_found = fixed_nlp.clone()
solve_data.best_solution_found_time = get_main_elapsed_time(
solve_data.timing)
if config.strategy == 'GOA':
if solve_data.objective_sense == minimize:
solve_data.num_no_good_cuts_added.update({
solve_data.UB:
len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts)
})
else:
solve_data.num_no_good_cuts_added.update({
solve_data.LB:
len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts)
})
# add obj increasing constraint for fp
if fp:
solve_data.mip.MindtPy_utils.cuts.del_component(
'improving_objective_cut')
if solve_data.objective_sense == minimize:
solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint(
expr=solve_data.mip.MindtPy_utils.objective_value <=
solve_data.UB -
config.fp_cutoffdecr * max(1, abs(solve_data.UB)))
else:
solve_data.mip.MindtPy_utils.cuts.improving_objective_cut = Constraint(
expr=solve_data.mip.MindtPy_utils.objective_value >=
solve_data.LB +
config.fp_cutoffdecr * max(1, abs(solve_data.UB)))
# Add the linear cut
if config.strategy == 'OA' or fp:
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
add_oa_cuts(solve_data.mip, dual_values, solve_data, config)
elif config.strategy == 'GOA':
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
add_affine_cuts(solve_data, config)
# elif config.strategy == 'PSC':
# # !!THIS SEEMS LIKE A BUG!! - mrmundt #
# add_psc_cut(solve_data, config)
# elif config.strategy == 'GBD':
# # !!THIS SEEMS LIKE A BUG!! - mrmundt #
# add_gbd_cut(solve_data, config)
var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list)
if config.add_no_good_cuts:
add_no_good_cuts(var_values, solve_data, config, feasible=True)
config.call_after_subproblem_feasible(fixed_nlp, solve_data)
def handle_NLP_subproblem_optimal(fixed_nlp, solve_data, config):
"""
This function copies the result of the NLP solver function ('solve_NLP_subproblem') to the working model, updates
the bounds, adds OA and integer cuts, and then stores the new solution if it is the new best solution. This
function handles the result of the latest iteration of solving the NLP subproblem given an optimal solution.
Parameters
----------
fixed_nlp: Pyomo model
fixed NLP from the model
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
"""
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.working_model.MindtPy_utils.variable_list,
config)
if config.use_dual:
for c in fixed_nlp.tmp_duals:
if fixed_nlp.dual.get(c, None) is None:
fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c]
dual_values = list(fixed_nlp.dual[c]
for c in fixed_nlp.MindtPy_utils.constraint_list)
else:
dual_values = None
main_objective = next(
fixed_nlp.component_data_objects(Objective, active=True))
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 = fixed_nlp.clone()
solve_data.best_solution_found_time = get_main_elapsed_time(
solve_data.timing)
if config.strategy == 'GOA':
if solve_data.results.problem.sense == ProblemSense.minimize:
solve_data.num_no_good_cuts_added.update({
solve_data.UB:
len(solve_data.mip.MindtPy_utils.MindtPy_linear_cuts.
integer_cuts)
})
else:
solve_data.num_no_good_cuts_added.update({
solve_data.LB:
len(solve_data.mip.MindtPy_utils.MindtPy_linear_cuts.
integer_cuts)
})
# Add the linear cut
if config.strategy == 'OA':
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
add_oa_cuts(solve_data.mip, dual_values, solve_data, config)
elif config.strategy == "GOA":
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
add_affine_cuts(solve_data, config)
elif config.strategy == 'PSC':
# !!THIS SEEMS LIKE A BUG!! - mrmundt #
add_psc_cut(solve_data, config)
elif config.strategy == 'GBD':
# !!THIS SEEMS LIKE A BUG!! - mrmundt #
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.
var_values = list(v.value for v in fixed_nlp.MindtPy_utils.variable_list)
if config.add_nogood_cuts:
add_nogood_cuts(var_values, solve_data, config, feasible=True)
config.call_after_subproblem_feasible(fixed_nlp, solve_data)
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: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
"""
m = solve_data.working_model.clone()
config.logger.info('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}:
if subprob_terminate_cond in {tc.feasible, tc.locallyOptimal}:
config.logger.info('relaxed NLP is not solved to optimality.')
dual_values = list(
m.dual[c] for c in
MindtPy.constraint_list) if config.calculate_dual else None
# Add OA cut
# This covers the case when the Lower bound does not exist.
# TODO: should we use the bound of the rNLP here?
if solve_data.objective_sense == minimize:
if not math.isnan(results.problem.lower_bound):
solve_data.LB = results.problem.lower_bound
solve_data.bound_improved = solve_data.LB > solve_data.LB_progress[
-1]
solve_data.LB_progress.append(results.problem.lower_bound)
elif not math.isnan(results.problem.upper_bound):
solve_data.UB = results.problem.upper_bound
solve_data.bound_improved = solve_data.UB < solve_data.UB_progress[
-1]
solve_data.UB_progress.append(results.problem.upper_bound)
main_objective = MindtPy.objective_list[-1]
config.logger.info(
'Relaxed NLP: OBJ: %s LB: %s UB: %s TIME:%ss' %
(value(main_objective.expr), solve_data.LB, solve_data.UB,
round(get_main_elapsed_time(solve_data.timing), 2)))
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 == 'OA':
add_oa_cuts(solve_data.mip, dual_values, solve_data, config)
elif config.strategy == 'GOA':
add_affine_cuts(solve_data, config)
# TODO check if value of the binary or integer varibles is 0/1 or integer value.
for var in solve_data.mip.MindtPy_utils.discrete_variable_list:
var.value = int(round(var.value))
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 init_rNLP(solve_data, config):
"""
Initialize the problem by solving the relaxed NLP (fixed binary variables) and then store the optimal variable
values obtained from solving the rNLP
Parameters
----------
solve_data: MindtPy Data Container
data container that holds solve-instance data
config: ConfigBlock
contains the specific configurations for the algorithm
"""
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_integer_vars').apply_to(m)
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)
with SuppressInfeasibleWarning():
results = SolverFactory(config.nlp_solver).solve(
m, tee=config.solver_tee, **nlp_args)
subprob_terminate_cond = results.solver.termination_condition
if subprob_terminate_cond in {tc.optimal, tc.feasible, tc.locallyOptimal}:
if subprob_terminate_cond in {tc.feasible, tc.locallyOptimal}:
config.logger.info(
'relaxed NLP is not solved to optimality.')
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) if config.use_dual else None
# Add OA cut
if main_objective.sense == minimize and not math.isnan(results['Problem'][0]['Lower bound']):
solve_data.LB = results['Problem'][0]['Lower bound']
elif not math.isnan(results['Problem'][0]['Upper bound']):
solve_data.UB = results['Problem'][0]['Upper bound']
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 in {'OA', 'GOA'}:
copy_var_list_values(m.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config, ignore_integrality=True)
if config.strategy == 'OA':
add_oa_cuts(solve_data.mip, dual_values, solve_data, config)
elif config.strategy == 'GOA':
add_affine_cuts(solve_data, config)
# TODO check if value of the binary or integer varibles is 0/1 or integer value.
for var in solve_data.mip.component_data_objects(ctype=Var):
if var.is_integer():
var.value = int(round(var.value))
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.')
elif subprob_terminate_cond is tc.maxTimeLimit:
config.logger.info(
'NLP subproblem failed to converge within time limit.')
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 handle_lazy_subproblem_optimal(self, fixed_nlp, solve_data, config,
opt):
"""This function copies the optimal solution of the fixed NLP subproblem to the MIP
main problem(explanation see below), updates bound, adds OA and no-good cuts,
stores incumbent solution if it has been improved.
Parameters
----------
fixed_nlp : Pyomo model
Integer-variable-fixed NLP model.
solve_data : MindtPySolveData
Data container that holds solve-instance data.
config : ConfigBlock
The specific configurations for MindtPy.
opt : SolverFactory
The cplex_persistent solver.
"""
if config.calculate_dual:
for c in fixed_nlp.tmp_duals:
if fixed_nlp.dual.get(c, None) is None:
fixed_nlp.dual[c] = fixed_nlp.tmp_duals[c]
dual_values = list(
fixed_nlp.dual[c]
for c in fixed_nlp.MindtPy_utils.constraint_list)
else:
dual_values = None
main_objective = fixed_nlp.MindtPy_utils.objective_list[-1]
update_primal_bound(solve_data, value(main_objective.expr))
if solve_data.solution_improved:
solve_data.best_solution_found = fixed_nlp.clone()
solve_data.best_solution_found_time = get_main_elapsed_time(
solve_data.timing)
if config.add_no_good_cuts or config.use_tabu_list:
if solve_data.results.problem.sense == ProblemSense.minimize:
solve_data.stored_bound.update(
{solve_data.UB: solve_data.LB})
else:
solve_data.stored_bound.update(
{solve_data.LB: solve_data.UB})
config.logger.info(
solve_data.fixed_nlp_log_formatter.format(
'*' if solve_data.solution_improved else ' ',
solve_data.nlp_iter, 'Fixed NLP', value(main_objective.expr),
solve_data.LB, solve_data.UB, solve_data.rel_gap,
get_main_elapsed_time(solve_data.timing)))
# In OA algorithm, OA cuts are generated based on the solution of the subproblem
# We need to first copy the value of variables from the subproblem and then add cuts
# since value(constr.body), value(jacs[constr][var]), value(var) are used in self.add_lazy_oa_cuts()
copy_var_list_values(fixed_nlp.MindtPy_utils.variable_list,
solve_data.mip.MindtPy_utils.variable_list,
config)
if config.strategy == 'OA':
self.add_lazy_oa_cuts(solve_data.mip, dual_values, solve_data,
config, opt)
if config.add_regularization is not None:
add_oa_cuts(solve_data.mip, dual_values, solve_data, config)
elif config.strategy == 'GOA':
self.add_lazy_affine_cuts(solve_data, config, opt)
if config.add_no_good_cuts:
var_values = list(v.value
for v in fixed_nlp.MindtPy_utils.variable_list)
self.add_lazy_no_good_cuts(var_values, solve_data, config, opt)