def solve(self, model, **kwds):
"""Solve the model.
Parameters
----------
model : Pyomo model
The MINLP model to be solved.
Returns
-------
results : SolverResults
Results from solving the MINLP problem by MindtPy.
"""
config = self.CONFIG(kwds.pop('options', {
}), preserve_implicit=True) # TODO: do we need to set preserve_implicit=True?
config.set_value(kwds)
set_up_logger(config)
check_config(config)
solve_data = set_up_solve_data(model, config)
if config.integer_to_binary:
TransformationFactory('contrib.integer_to_binary'). \
apply_to(solve_data.working_model)
new_logging_level = logging.INFO if config.tee else None
with time_code(solve_data.timing, 'total', is_main_timer=True), \
lower_logger_level_to(config.logger, new_logging_level), \
create_utility_block(solve_data.working_model, 'MindtPy_utils', solve_data):
config.logger.info(
'---------------------------------------------------------------------------------------------\n'
' Mixed-Integer Nonlinear Decomposition Toolbox in Pyomo (MindtPy) \n'
'---------------------------------------------------------------------------------------------\n'
'For more information, please visit https://pyomo.readthedocs.io/en/stable/contributed_packages/mindtpy.html')
MindtPy = solve_data.working_model.MindtPy_utils
setup_results_object(solve_data, config)
# In the process_objective function, as long as the objective function is nonlinear, it will be reformulated and the variable/constraint/objective lists will be updated.
# For OA/GOA/LP-NLP algorithm, if the objective funtion is linear, it will not be reformulated as epigraph constraint.
# If the objective function is linear, it will be reformulated as epigraph constraint only if the Feasibility Pump or ROA/RLP-NLP algorithm is activated. (move_objective = True)
# In some cases, the variable/constraint/objective lists will not be updated even if the objective is epigraph-reformulated.
# In Feasibility Pump, since the distance calculation only includes discrete variables and the epigraph slack variables are continuous variables, the Feasibility Pump algorithm will not affected even if the variable list are updated.
# In ROA and RLP/NLP, since the distance calculation does not include these epigraph slack variables, they should not be added to the variable list. (update_var_con_list = False)
# In the process_objective function, once the objective function has been reformulated as epigraph constraint, the variable/constraint/objective lists will not be updated only if the MINLP has a linear objective function and regularization is activated at the same time.
# This is because the epigraph constraint is very "flat" for branching rules. The original objective function will be used for the main problem and epigraph reformulation will be used for the projection problem.
# TODO: The logic here is too complicated, can we simplify it?
process_objective(solve_data, config,
move_objective=(config.init_strategy == 'FP'
or config.add_regularization is not None
or config.move_objective),
use_mcpp=config.use_mcpp,
update_var_con_list=config.add_regularization is None,
partition_nonlinear_terms=config.partition_obj_nonlinear_terms,
obj_handleable_polynomial_degree=solve_data.mip_objective_polynomial_degree,
constr_handleable_polynomial_degree=solve_data.mip_constraint_polynomial_degree
)
# The epigraph constraint is very "flat" for branching rules.
# If ROA/RLP-NLP is activated and the original objective function is linear, we will use the original objective for the main mip.
if MindtPy.objective_list[0].expr.polynomial_degree() in solve_data.mip_objective_polynomial_degree and config.add_regularization is not None:
MindtPy.objective_list[0].activate()
MindtPy.objective_constr.deactivate()
MindtPy.objective.deactivate()
# Save model initial values.
solve_data.initial_var_values = list(
v.value for v in MindtPy.variable_list)
# Store the initial model state as the best solution found. If we
# find no better solution, then we will restore from this copy.
solve_data.best_solution_found = None
solve_data.best_solution_found_time = None
# Record solver name
solve_data.results.solver.name = 'MindtPy' + str(config.strategy)
# Validate the model to ensure that MindtPy is able to solve it.
if not model_is_valid(solve_data, config):
return
# Create a model block in which to store the generated feasibility
# slack constraints. Do not leave the constraints on by default.
feas = MindtPy.feas_opt = Block()
feas.deactivate()
feas.feas_constraints = ConstraintList(
doc='Feasibility Problem Constraints')
# Create a model block in which to store the generated linear
# constraints. Do not leave the constraints on by default.
lin = MindtPy.cuts = Block()
lin.deactivate()
# no-good cuts exclude particular discrete decisions
lin.no_good_cuts = ConstraintList(doc='no-good cuts')
# Feasible no-good cuts exclude discrete realizations that have
# been explored via an NLP subproblem. Depending on model
# characteristics, the user may wish to revisit NLP subproblems
# (with a different initialization, for example). Therefore, these
# cuts are not enabled by default.
#
# Note: these cuts will only exclude integer realizations that are
# not already in the primary no_good_cuts ConstraintList.
lin.feasible_no_good_cuts = ConstraintList(
doc='explored no-good cuts')
lin.feasible_no_good_cuts.deactivate()
if config.feasibility_norm == 'L1' or config.feasibility_norm == 'L2':
feas.nl_constraint_set = RangeSet(len(MindtPy.nonlinear_constraint_list),
doc='Integer index set over the nonlinear constraints.')
# Create slack variables for feasibility problem
feas.slack_var = Var(feas.nl_constraint_set,
domain=NonNegativeReals, initialize=1)
else:
feas.slack_var = Var(domain=NonNegativeReals, initialize=1)
# Create slack variables for OA cuts
if config.add_slack:
lin.slack_vars = VarList(
bounds=(0, config.max_slack), initialize=0, domain=NonNegativeReals)
# Initialize the main problem
with time_code(solve_data.timing, 'initialization'):
MindtPy_initialize_main(solve_data, config)
# Algorithm main loop
with time_code(solve_data.timing, 'main loop'):
MindtPy_iteration_loop(solve_data, config)
if solve_data.best_solution_found is not None:
# Update values in original model
copy_var_list_values(
from_list=solve_data.best_solution_found.MindtPy_utils.variable_list,
to_list=MindtPy.variable_list,
config=config)
copy_var_list_values(
MindtPy.variable_list,
[i for i in solve_data.original_model.component_data_objects(
Var) if not i.fixed],
config)
# exclude fixed variables here. This is consistent with the definition of variable_list in GDPopt.util
if solve_data.objective_sense == minimize:
solve_data.results.problem.lower_bound = solve_data.dual_bound
solve_data.results.problem.upper_bound = solve_data.primal_bound
else:
solve_data.results.problem.lower_bound = solve_data.primal_bound
solve_data.results.problem.upper_bound = solve_data.dual_bound
solve_data.results.solver.timing = solve_data.timing
solve_data.results.solver.user_time = solve_data.timing.total
solve_data.results.solver.wallclock_time = solve_data.timing.total
solve_data.results.solver.iterations = solve_data.mip_iter
solve_data.results.solver.num_infeasible_nlp_subproblem = solve_data.nlp_infeasible_counter
solve_data.results.solver.best_solution_found_time = solve_data.best_solution_found_time
solve_data.results.solver.primal_integral = get_primal_integral(solve_data, config)
solve_data.results.solver.dual_integral = get_dual_integral(solve_data, config)
solve_data.results.solver.primal_dual_gap_integral = solve_data.results.solver.primal_integral + \
solve_data.results.solver.dual_integral
config.logger.info(' {:<25}: {:>7.4f} '.format(
'Primal-dual gap integral', solve_data.results.solver.primal_dual_gap_integral))
if config.single_tree:
solve_data.results.solver.num_nodes = solve_data.nlp_iter - \
(1 if config.init_strategy == 'rNLP' else 0)
return solve_data.results
def solve(self, model, **kwds):
"""Solve the model.
Warning: this solver is still in beta. Keyword arguments subject to
change. Undocumented keyword arguments definitely subject to change.
Args:
model (Block): a Pyomo model or block to be solved.
"""
config = self.CONFIG(kwds.pop('options', {}))
config.set_value(kwds)
set_up_logger(config)
check_config(config)
solve_data = set_up_solve_data(model, config)
if config.integer_to_binary:
TransformationFactory('contrib.integer_to_binary'). \
apply_to(solve_data.working_model)
new_logging_level = logging.INFO if config.tee else None
with time_code(solve_data.timing, 'total', is_main_timer=True), \
lower_logger_level_to(config.logger, new_logging_level), \
create_utility_block(solve_data.working_model, 'MindtPy_utils', solve_data):
config.logger.info(
'---------------------------------------------------------------------------------------------\n'
' Mixed-Integer Nonlinear Decomposition Toolbox in Pyomo (MindtPy) \n'
'---------------------------------------------------------------------------------------------\n'
'For more information, please visit https://pyomo.readthedocs.io/en/stable/contributed_packages/mindtpy.html')
MindtPy = solve_data.working_model.MindtPy_utils
setup_results_object(solve_data, config)
process_objective(solve_data, config,
move_linear_objective=(config.init_strategy == 'FP'
or config.add_regularization is not None),
use_mcpp=config.use_mcpp,
updata_var_con_list=config.add_regularization is None
)
# The epigraph constraint is very "flat" for branching rules,
# we want to use to original model for the main mip.
if MindtPy.objective_list[0].expr.polynomial_degree() in {1, 0} and config.add_regularization is not None:
MindtPy.objective_list[0].activate()
MindtPy.objective_constr.deactivate()
MindtPy.objective.deactivate()
# Save model initial values.
solve_data.initial_var_values = list(
v.value for v in MindtPy.variable_list)
# Store the initial model state as the best solution found. If we
# find no better solution, then we will restore from this copy.
solve_data.best_solution_found = None
solve_data.best_solution_found_time = None
# Record solver name
solve_data.results.solver.name = 'MindtPy' + str(config.strategy)
# Validate the model to ensure that MindtPy is able to solve it.
if not model_is_valid(solve_data, config):
return
# Create a model block in which to store the generated feasibility
# slack constraints. Do not leave the constraints on by default.
feas = MindtPy.feas_opt = Block()
feas.deactivate()
feas.feas_constraints = ConstraintList(
doc='Feasibility Problem Constraints')
# Create a model block in which to store the generated linear
# constraints. Do not leave the constraints on by default.
lin = MindtPy.cuts = Block()
lin.deactivate()
# no-good cuts exclude particular discrete decisions
lin.no_good_cuts = ConstraintList(doc='no-good cuts')
# Feasible no-good cuts exclude discrete realizations that have
# been explored via an NLP subproblem. Depending on model
# characteristics, the user may wish to revisit NLP subproblems
# (with a different initialization, for example). Therefore, these
# cuts are not enabled by default.
#
# Note: these cuts will only exclude integer realizations that are
# not already in the primary no_good_cuts ConstraintList.
lin.feasible_no_good_cuts = ConstraintList(
doc='explored no-good cuts')
lin.feasible_no_good_cuts.deactivate()
if config.feasibility_norm == 'L1' or config.feasibility_norm == 'L2':
feas.nl_constraint_set = RangeSet(len(MindtPy.nonlinear_constraint_list),
doc='Integer index set over the nonlinear constraints.')
# Create slack variables for feasibility problem
feas.slack_var = Var(feas.nl_constraint_set,
domain=NonNegativeReals, initialize=1)
else:
feas.slack_var = Var(domain=NonNegativeReals, initialize=1)
# Create slack variables for OA cuts
if config.add_slack:
lin.slack_vars = VarList(
bounds=(0, config.max_slack), initialize=0, domain=NonNegativeReals)
# Initialize the main problem
with time_code(solve_data.timing, 'initialization'):
MindtPy_initialize_main(solve_data, config)
# Algorithm main loop
with time_code(solve_data.timing, 'main loop'):
MindtPy_iteration_loop(solve_data, config)
if solve_data.best_solution_found is not None:
# Update values in original model
copy_var_list_values(
from_list=solve_data.best_solution_found.MindtPy_utils.variable_list,
to_list=MindtPy.variable_list,
config=config)
copy_var_list_values(
MindtPy.variable_list,
[i for i in solve_data.original_model.component_data_objects(
Var) if not i.fixed],
config)
# exclude fixed variables here. This is consistent with the definition of variable_list in GDPopt.util
solve_data.results.problem.lower_bound = solve_data.LB
solve_data.results.problem.upper_bound = solve_data.UB
solve_data.results.solver.timing = solve_data.timing
solve_data.results.solver.user_time = solve_data.timing.total
solve_data.results.solver.wallclock_time = solve_data.timing.total
solve_data.results.solver.iterations = solve_data.mip_iter
solve_data.results.solver.num_infeasible_nlp_subproblem = solve_data.nlp_infeasible_counter
solve_data.results.solver.best_solution_found_time = solve_data.best_solution_found_time
if config.single_tree:
solve_data.results.solver.num_nodes = solve_data.nlp_iter - \
(1 if config.init_strategy == 'rNLP' else 0)
return solve_data.results
def test_handle_termination_condition(self):
"""Test the outer approximation decomposition algorithm."""
model = SimpleMINLP()
config = _get_MindtPy_config()
solve_data = set_up_solve_data(model, config)
with time_code(solve_data.timing, 'total', is_main_timer=True), \
create_utility_block(solve_data.working_model, 'MindtPy_utils', solve_data):
MindtPy = solve_data.working_model.MindtPy_utils
MindtPy = solve_data.working_model.MindtPy_utils
setup_results_object(solve_data, config)
process_objective(solve_data, config,
move_objective=(config.init_strategy == 'FP'
or config.add_regularization is not None),
use_mcpp=config.use_mcpp,
update_var_con_list=config.add_regularization is None
)
feas = MindtPy.feas_opt = Block()
feas.deactivate()
feas.feas_constraints = ConstraintList(
doc='Feasibility Problem Constraints')
lin = MindtPy.cuts = Block()
lin.deactivate()
if config.feasibility_norm == 'L1' or config.feasibility_norm == 'L2':
feas.nl_constraint_set = RangeSet(len(MindtPy.nonlinear_constraint_list),
doc='Integer index set over the nonlinear constraints.')
# Create slack variables for feasibility problem
feas.slack_var = Var(feas.nl_constraint_set,
domain=NonNegativeReals, initialize=1)
else:
feas.slack_var = Var(domain=NonNegativeReals, initialize=1)
# no-good cuts exclude particular discrete decisions
lin.no_good_cuts = ConstraintList(doc='no-good cuts')
fixed_nlp = solve_data.working_model.clone()
TransformationFactory('core.fix_integer_vars').apply_to(fixed_nlp)
MindtPy_initialize_main(solve_data, config)
# test handle_subproblem_other_termination
termination_condition = tc.maxIterations
config.add_no_good_cuts = True
handle_subproblem_other_termination(fixed_nlp, termination_condition,
solve_data, config)
self.assertEqual(
len(solve_data.mip.MindtPy_utils.cuts.no_good_cuts), 1)
# test handle_main_other_conditions
main_mip, main_mip_results = solve_main(solve_data, config)
main_mip_results.solver.termination_condition = tc.infeasible
handle_main_other_conditions(
solve_data.mip, main_mip_results, solve_data, config)
self.assertIs(
solve_data.results.solver.termination_condition, tc.feasible)
main_mip_results.solver.termination_condition = tc.unbounded
handle_main_other_conditions(
solve_data.mip, main_mip_results, solve_data, config)
self.assertIn(main_mip.MindtPy_utils.objective_bound,
main_mip.component_data_objects(ctype=Constraint))
main_mip.MindtPy_utils.del_component('objective_bound')
main_mip_results.solver.termination_condition = tc.infeasibleOrUnbounded
handle_main_other_conditions(
solve_data.mip, main_mip_results, solve_data, config)
self.assertIn(main_mip.MindtPy_utils.objective_bound,
main_mip.component_data_objects(ctype=Constraint))
main_mip_results.solver.termination_condition = tc.maxTimeLimit
handle_main_other_conditions(
solve_data.mip, main_mip_results, solve_data, config)
self.assertIs(
solve_data.results.solver.termination_condition, tc.maxTimeLimit)
main_mip_results.solver.termination_condition = tc.other
main_mip_results.solution.status = SolutionStatus.feasible
handle_main_other_conditions(
solve_data.mip, main_mip_results, solve_data, config)
for v1, v2 in zip(main_mip.MindtPy_utils.variable_list, solve_data.working_model.MindtPy_utils.variable_list):
self.assertEqual(v1.value, v2.value)
# test handle_feasibility_subproblem_tc
feas_subproblem = solve_data.working_model.clone()
add_feas_slacks(feas_subproblem, config)
MindtPy = feas_subproblem.MindtPy_utils
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)
handle_feasibility_subproblem_tc(
tc.optimal, MindtPy, solve_data, config)
handle_feasibility_subproblem_tc(
tc.infeasible, MindtPy, solve_data, config)
self.assertIs(solve_data.should_terminate, True)
self.assertIs(solve_data.results.solver.status, SolverStatus.error)
solve_data.should_terminate = False
solve_data.results.solver.status = None
handle_feasibility_subproblem_tc(
tc.maxIterations, MindtPy, solve_data, config)
self.assertIs(solve_data.should_terminate, True)
self.assertIs(solve_data.results.solver.status, SolverStatus.error)
solve_data.should_terminate = False
solve_data.results.solver.status = None
handle_feasibility_subproblem_tc(
tc.solverFailure, MindtPy, solve_data, config)
self.assertIs(solve_data.should_terminate, True)
self.assertIs(solve_data.results.solver.status, SolverStatus.error)
# test NLP subproblem infeasible
solve_data.working_model.Y[1].value = 0
solve_data.working_model.Y[2].value = 0
solve_data.working_model.Y[3].value = 0
fixed_nlp, fixed_nlp_results = solve_subproblem(solve_data, config)
solve_data.working_model.Y[1].value = None
solve_data.working_model.Y[2].value = None
solve_data.working_model.Y[3].value = None
# test handle_nlp_subproblem_tc
fixed_nlp_results.solver.termination_condition = tc.maxTimeLimit
handle_nlp_subproblem_tc(
fixed_nlp, fixed_nlp_results, solve_data, config)
self.assertIs(solve_data.should_terminate, True)
self.assertIs(
solve_data.results.solver.termination_condition, tc.maxTimeLimit)
fixed_nlp_results.solver.termination_condition = tc.maxEvaluations
handle_nlp_subproblem_tc(
fixed_nlp, fixed_nlp_results, solve_data, config)
self.assertIs(solve_data.should_terminate, True)
self.assertIs(
solve_data.results.solver.termination_condition, tc.maxEvaluations)
fixed_nlp_results.solver.termination_condition = tc.maxIterations
handle_nlp_subproblem_tc(
fixed_nlp, fixed_nlp_results, solve_data, config)
self.assertIs(solve_data.should_terminate, True)
self.assertIs(
solve_data.results.solver.termination_condition, tc.maxEvaluations)
# test handle_fp_main_tc
config.init_strategy = 'FP'
solve_data.fp_iter = 1
init_rNLP(solve_data, config)
feas_main, feas_main_results = solve_main(
solve_data, config, fp=True)
feas_main_results.solver.termination_condition = tc.optimal
fp_should_terminate = handle_fp_main_tc(
feas_main_results, solve_data, config)
self.assertIs(fp_should_terminate, False)
feas_main_results.solver.termination_condition = tc.maxTimeLimit
fp_should_terminate = handle_fp_main_tc(
feas_main_results, solve_data, config)
self.assertIs(fp_should_terminate, True)
self.assertIs(
solve_data.results.solver.termination_condition, tc.maxTimeLimit)
feas_main_results.solver.termination_condition = tc.infeasible
fp_should_terminate = handle_fp_main_tc(
feas_main_results, solve_data, config)
self.assertIs(fp_should_terminate, True)
feas_main_results.solver.termination_condition = tc.unbounded
fp_should_terminate = handle_fp_main_tc(
feas_main_results, solve_data, config)
self.assertIs(fp_should_terminate, True)
feas_main_results.solver.termination_condition = tc.other
feas_main_results.solution.status = SolutionStatus.feasible
fp_should_terminate = handle_fp_main_tc(
feas_main_results, solve_data, config)
self.assertIs(fp_should_terminate, False)
feas_main_results.solver.termination_condition = tc.solverFailure
fp_should_terminate = handle_fp_main_tc(
feas_main_results, solve_data, config)
self.assertIs(fp_should_terminate, True)
# test generate_norm_constraint
fp_nlp = solve_data.working_model.clone()
config.fp_main_norm = 'L1'
generate_norm_constraint(fp_nlp, solve_data, config)
self.assertIsNotNone(fp_nlp.MindtPy_utils.find_component(
'L1_norm_constraint'))
config.fp_main_norm = 'L2'
generate_norm_constraint(fp_nlp, solve_data, config)
self.assertIsNotNone(fp_nlp.find_component('norm_constraint'))
fp_nlp.del_component('norm_constraint')
config.fp_main_norm = 'L_infinity'
generate_norm_constraint(fp_nlp, solve_data, config)
self.assertIsNotNone(fp_nlp.find_component('norm_constraint'))
# test set_solver_options
config.mip_solver = 'gams'
config.threads = 1
opt = SolverFactory(config.mip_solver)
set_solver_options(opt, solve_data, config,
'mip', regularization=False)
config.mip_solver = 'gurobi'
config.mip_regularization_solver = 'gurobi'
config.regularization_mip_threads = 1
opt = SolverFactory(config.mip_solver)
set_solver_options(opt, solve_data, config,
'mip', regularization=True)
config.nlp_solver = 'gams'
config.nlp_solver_args['solver'] = 'ipopt'
set_solver_options(opt, solve_data, config,
'nlp', regularization=False)
config.nlp_solver_args['solver'] = 'ipopth'
set_solver_options(opt, solve_data, config,
'nlp', regularization=False)
config.nlp_solver_args['solver'] = 'conopt'
set_solver_options(opt, solve_data, config,
'nlp', regularization=False)
config.nlp_solver_args['solver'] = 'msnlp'
set_solver_options(opt, solve_data, config,
'nlp', regularization=False)
config.nlp_solver_args['solver'] = 'baron'
set_solver_options(opt, solve_data, config,
'nlp', regularization=False)
# test algorithm_should_terminate
solve_data.should_terminate = True
solve_data.primal_bound = float('inf')
self.assertIs(algorithm_should_terminate(
solve_data, config, check_cycling=False), True)
self.assertIs(
solve_data.results.solver.termination_condition, tc.noSolution)
solve_data.primal_bound = 100
self.assertIs(algorithm_should_terminate(
solve_data, config, check_cycling=False), True)
self.assertIs(
solve_data.results.solver.termination_condition, tc.feasible)
solve_data.primal_bound_progress = [float('inf'), 5, 4, 3, 2, 1]
solve_data.primal_bound_progress_time = [1, 2, 3, 4, 5, 6]
solve_data.primal_bound = 1
self.assertEqual(get_primal_integral(solve_data, config), 14.5)
solve_data.dual_bound_progress = [float('-inf'), 1, 2, 3, 4, 5]
solve_data.dual_bound_progress_time = [1, 2, 3, 4, 5, 6]
solve_data.dual_bound = 5
self.assertEqual(get_dual_integral(solve_data, config), 14.1)
# test check_config
config.add_regularization = 'level_L1'
config.regularization_mip_threads = 0
config.threads = 8
check_config(config)
self.assertEqual(config.regularization_mip_threads, 8)
config.mip_solver = 'cplex'
config.single_tree = True
check_config(config)
self.assertEqual(config.mip_solver, 'cplex_persistent')
self.assertEqual(config.threads, 1)
config.add_slack = True
config.max_slack == 0.0
check_config(config)
self.assertEqual(config.add_slack, False)
config.strategy = 'GOA'
config.add_slack = True
config.use_mcpp = False
config.equality_relaxation = True
config.use_fbbt = False
config.add_no_good_cuts = False
config.use_tabu_list = False
check_config(config)
self.assertTrue(config.use_mcpp)
self.assertTrue(config.use_fbbt)
self.assertFalse(config.add_slack)
self.assertFalse(config.equality_relaxation)
self.assertTrue(config.add_no_good_cuts)
self.assertFalse(config.use_tabu_list)
config.single_tree = False
config.strategy = 'FP'
config.init_strategy = 'rNLP'
config.iteration_limit = 100
config.add_no_good_cuts = False
config.use_tabu_list = True
check_config(config)
self.assertEqual(config.init_strategy, 'FP')
self.assertEqual(config.iteration_limit, 0)
self.assertEqual(config.add_no_good_cuts, True)
self.assertEqual(config.use_tabu_list, False)
def solve(self, model, **kwds):
"""Solve the model.
Warning: this solver is still in beta. Keyword arguments subject to
change. Undocumented keyword arguments definitely subject to change.
Args:
model (Block): a Pyomo model or block to be solved
"""
config = self.CONFIG(kwds.pop('options', {}))
config.set_value(kwds)
solve_data = MindtPySolveData()
solve_data.results = SolverResults()
solve_data.timing = Bunch()
solve_data.curr_int_sol = []
solve_data.should_terminate = False
solve_data.integer_list = []
check_config(config)
# if the objective function is a constant, dual bound constraint is not added.
obj = next(model.component_data_objects(ctype=Objective, active=True))
if obj.expr.polynomial_degree() == 0:
config.use_dual_bound = False
if config.use_fbbt:
fbbt(model)
# TODO: logging_level is not logging.INFO here
config.logger.info(
'Use the fbbt to tighten the bounds of variables')
solve_data.original_model = model
solve_data.working_model = model.clone()
if config.integer_to_binary:
TransformationFactory('contrib.integer_to_binary'). \
apply_to(solve_data.working_model)
new_logging_level = logging.INFO if config.tee else None
with time_code(solve_data.timing, 'total', is_main_timer=True), \
lower_logger_level_to(config.logger, new_logging_level), \
create_utility_block(solve_data.working_model, 'MindtPy_utils', solve_data):
config.logger.info('---Starting MindtPy---')
MindtPy = solve_data.working_model.MindtPy_utils
setup_results_object(solve_data, config)
process_objective(
solve_data,
config,
move_linear_objective=(config.init_strategy == 'FP' or
config.add_regularization is not None),
use_mcpp=config.use_mcpp,
updata_var_con_list=config.add_regularization is None)
# The epigraph constraint is very "flat" for branching rules,
# we want to use to original model for the main mip.
if MindtPy.objective_list[0].expr.polynomial_degree() in {
1, 0
} and config.add_regularization is not None:
MindtPy.objective_list[0].activate()
MindtPy.objective_constr.deactivate()
MindtPy.objective.deactivate()
# Save model initial values.
solve_data.initial_var_values = list(
v.value for v in MindtPy.variable_list)
# Store the initial model state as the best solution found. If we
# find no better solution, then we will restore from this copy.
solve_data.best_solution_found = None
solve_data.best_solution_found_time = None
# Record solver name
solve_data.results.solver.name = 'MindtPy' + str(config.strategy)
# Validate the model to ensure that MindtPy is able to solve it.
if not model_is_valid(solve_data, config):
return
# Create a model block in which to store the generated feasibility
# slack constraints. Do not leave the constraints on by default.
feas = MindtPy.feas_opt = Block()
feas.deactivate()
feas.feas_constraints = ConstraintList(
doc='Feasibility Problem Constraints')
# Create a model block in which to store the generated linear
# constraints. Do not leave the constraints on by default.
lin = MindtPy.cuts = Block()
lin.deactivate()
# no-good cuts exclude particular discrete decisions
lin.no_good_cuts = ConstraintList(doc='no-good cuts')
# Feasible no-good cuts exclude discrete realizations that have
# been explored via an NLP subproblem. Depending on model
# characteristics, the user may wish to revisit NLP subproblems
# (with a different initialization, for example). Therefore, these
# cuts are not enabled by default.
#
# Note: these cuts will only exclude integer realizations that are
# not already in the primary no_good_cuts ConstraintList.
lin.feasible_no_good_cuts = ConstraintList(
doc='explored no-good cuts')
lin.feasible_no_good_cuts.deactivate()
# Set up iteration counters
solve_data.nlp_iter = 0
solve_data.mip_iter = 0
solve_data.mip_subiter = 0
solve_data.nlp_infeasible_counter = 0
if config.init_strategy == 'FP':
solve_data.fp_iter = 1
# set up bounds
solve_data.LB = float('-inf')
solve_data.UB = float('inf')
solve_data.LB_progress = [solve_data.LB]
solve_data.UB_progress = [solve_data.UB]
if config.single_tree and (config.add_no_good_cuts
or config.use_tabu_list):
solve_data.stored_bound = {}
if config.strategy == 'GOA' and (config.add_no_good_cuts
or config.use_tabu_list):
solve_data.num_no_good_cuts_added = {}
# Set of NLP iterations for which cuts were generated
lin.nlp_iters = Set(dimen=1)
# Set of MIP iterations for which cuts were generated in ECP
lin.mip_iters = Set(dimen=1)
if config.feasibility_norm == 'L1' or config.feasibility_norm == 'L2':
feas.nl_constraint_set = RangeSet(
len(MindtPy.nonlinear_constraint_list),
doc='Integer index set over the nonlinear constraints.')
# Create slack variables for feasibility problem
feas.slack_var = Var(feas.nl_constraint_set,
domain=NonNegativeReals,
initialize=1)
else:
feas.slack_var = Var(domain=NonNegativeReals, initialize=1)
# Create slack variables for OA cuts
if config.add_slack:
lin.slack_vars = VarList(bounds=(0, config.max_slack),
initialize=0,
domain=NonNegativeReals)
# Flag indicating whether the solution improved in the past
# iteration or not
solve_data.solution_improved = False
solve_data.bound_improved = False
if config.nlp_solver == 'ipopt':
if not hasattr(solve_data.working_model, 'ipopt_zL_out'):
solve_data.working_model.ipopt_zL_out = Suffix(
direction=Suffix.IMPORT)
if not hasattr(solve_data.working_model, 'ipopt_zU_out'):
solve_data.working_model.ipopt_zU_out = Suffix(
direction=Suffix.IMPORT)
# Initialize the main problem
with time_code(solve_data.timing, 'initialization'):
MindtPy_initialize_main(solve_data, config)
# Algorithm main loop
with time_code(solve_data.timing, 'main loop'):
MindtPy_iteration_loop(solve_data, config)
if solve_data.best_solution_found is not None:
# Update values in original model
copy_var_list_values(from_list=solve_data.best_solution_found.
MindtPy_utils.variable_list,
to_list=MindtPy.variable_list,
config=config)
copy_var_list_values(MindtPy.variable_list, [
i
for i in solve_data.original_model.component_data_objects(
Var) if not i.fixed
], config)
# exclude fixed variables here. This is consistent with the definition of variable_list in GDPopt.util
solve_data.results.problem.lower_bound = solve_data.LB
solve_data.results.problem.upper_bound = solve_data.UB
solve_data.results.solver.timing = solve_data.timing
solve_data.results.solver.user_time = solve_data.timing.total
solve_data.results.solver.wallclock_time = solve_data.timing.total
solve_data.results.solver.iterations = solve_data.mip_iter
solve_data.results.solver.num_infeasible_nlp_subproblem = solve_data.nlp_infeasible_counter
solve_data.results.solver.best_solution_found_time = solve_data.best_solution_found_time
if config.single_tree:
solve_data.results.solver.num_nodes = solve_data.nlp_iter - \
(1 if config.init_strategy == 'rNLP' else 0)
return solve_data.results