GDP_LOA_Solver

(class from pyomo.contrib.gdpopt.loa)

class pyomo.contrib.gdpopt.loa.GDP_LOA_Solver(**kwds)

Bases: _GDPoptAlgorithm, _OAAlgorithmMixIn

The GDPopt (Generalized Disjunctive Programming optimizer) logic-based outer approximation (LOA) solver.

Accepts models that can include nonlinear, continuous variables and constraints, as well as logical conditions. For nonconvex problems, LOA may not report rigorous dual bounds.

__init__(**kwds)

This is a common init method for all the GDPopt algorithms, so that we correctly set up the config arguments and initialize the generic parts of the algorithm state.

Methods

__init__(**kwds)	This is a common init method for all the GDPopt algorithms, so that we correctly set up the config arguments and initialize the generic parts of the algorithm state.
any_termination_criterion_met(config)
available([exception_flag])	Solver is always available.
bounds_converged(config)
license_is_valid()
primal_bound()
reached_iteration_limit(config)
reached_time_limit(config)
relative_gap()	Returns current relative optimality gap.
solve(model, **kwds)	Solve the model.
update_incumbent(util_block)
version()	Return a 3-tuple describing the solver version.

Attributes

CONFIG
algorithm
objective_sense

Member Documentation

available(exception_flag=True)

Solver is always available. Though subsolvers may not be, they will raise an error when the time comes.

relative_gap()

Returns current relative optimality gap.

Note that this gap is not necessarily monotonically decreasing if at some point the primal bound changes signs.

solve(model, **kwds)

Solve the model.

Parameters:

model (Block) – the Pyomo model or block to be solved

Keyword Arguments:

• iterlim (NonNegativeInt, optional) – Iteration limit.

• time_limit (PositiveInt, optional) – Seconds allowed until terminated. Note that the time limit can currently only be enforced between subsolver invocations. You may need to set subsolver time limits as well.

• tee (bool, default=False) – Stream output to terminal.

• logger (a_logger, default=<Logger pyomo.contrib.gdpopt (WARNING)>) – The logger object or name to use for reporting.

• integer_tolerance (default=1e-05) – Tolerance on integral values.

• constraint_tolerance (default=1e-06) –

  Tolerance on constraint satisfaction.

  Increasing this tolerance corresponds to being more conservative in declaring the model or an NLP subproblem to be infeasible.

• variable_tolerance (default=1e-08) – Tolerance on variable bounds.

• subproblem_initialization_method (default=<function restore_vars_to_original_values at 0x7f0fefb42480>) –

  Callback to specify custom routines for initializing the (MI)NLP subproblems. This method is called after the discrete problem solution is fixed in the subproblem and before the subproblem is solved (or pre-solved).

  For algorithms with a discrete problem relaxation: This method accepts three arguments: the solver object, the subproblem GDPopt utility block and the discrete problem GDPopt utility block. The discrete problem contains the most recent discrete problem solution.

  For algorithms without a discrete problem relaxation: This method accepts four arguments: the list of Disjuncts that are currently fixed as being active, a list of values for the non-indicator BooleanVars (empty if force_nlp_subproblem=False), and a list of values for the integer vars (also empty if force_nlp_subproblem=False), and last the subproblem GDPopt utility block.

  The return of this method will be unused: The method should directly set the value of the variables on the subproblem

• call_before_subproblem_solve (default=<class 'pyomo.contrib.gdpopt.util._DoNothing'>) –

  Callback called right before the (MI)NLP subproblem is solved. Takes three arguments: The solver object, the subproblem and the GDPopt utility block on the subproblem.

  Note that unless you are very confident in what you are doing, the subproblem should not be modified in this callback: it should be used to interrogate the problem only.

  To initialize the problem before it is solved, please specify a method in the ‘subproblem_initialization_method’ argument.

• call_after_subproblem_solve (default=<class 'pyomo.contrib.gdpopt.util._DoNothing'>) –

  Callback called right after the (MI)NLP subproblem is solved. Takes three arguments: The solver object, the subproblem, and the GDPopt utility block on the subproblem.

  Note that unless you are very confident in what you are doing, the subproblem should not be modified in this callback: it should be used to interrogate the problem only.

• call_after_subproblem_feasible (default=<class 'pyomo.contrib.gdpopt.util._DoNothing'>) –

  Callback called right after the (MI)NLP subproblem is solved, if it was feasible. Takes three arguments: The solver object, the subproblem and the GDPopt utility block on the subproblem.

  Note that unless you are very confident in what you are doing, the subproblem should not be modified in this callback: it should be used to interrogate the problem only.

• force_subproblem_nlp (default=False) – Force subproblems to be NLP, even if discrete variables exist.

• subproblem_presolve (bool, default=True) – Flag to enable or disable subproblem presolve. Default=True.

• tighten_nlp_var_bounds (bool, default=False) – Whether or not to do feasibility-based bounds tightening on the variables in the NLP subproblem before solving it.

• round_discrete_vars (default=True) – Flag to round subproblem discrete variable values to the nearest integer. Rounding is done before fixing disjuncts.

• max_fbbt_iterations (PositiveInt, default=3) – Maximum number of feasibility-based bounds tightening iterations to do during NLP subproblem preprocessing.

• init_strategy (_init_strategy_deprecation, optional) – DEPRECATED: Please use ‘init_algorithm’ instead.

• init_algorithm (In{'no_init': <class 'pyomo.contrib.gdpopt.util._DoNothing'>, 'set_covering': <function init_set_covering at 0x7f0fefb42340>, 'max_binary': <function init_max_binaries at 0x7f0fefb420c0>, 'fix_disjuncts': <function init_fixed_disjuncts at 0x7f0fefb41ee0>, 'custom_disjuncts': <function init_custom_disjuncts at 0x7f0fefb41e40>}, default='set_covering') – Selects the initialization algorithm to use when generating the initial cuts to construct the discrete problem.

• custom_init_disjuncts (optional) – List of disjunct sets to use for initialization.

• max_slack (NonNegativeFloat, default=1000) – Upper bound on slack variables for OA

• OA_penalty_factor (NonNegativeFloat, default=1000) – Penalty multiplication term for slack variables on the objective value.

• set_cover_iterlim (NonNegativeInt, default=8) – Limit on the number of set covering iterations.

• discrete_problem_transformation (default='gdp.bigm') – Name of the transformation to use to transform the discrete problem from a GDP to an algebraic model.

• call_before_discrete_problem_solve (default=<class 'pyomo.contrib.gdpopt.util._DoNothing'>) –

  Callback called right before the MILP discrete problem is solved. Takes three arguments: The solver object, the discrete problem, and the GDPopt utility block on the discrete problem.

  Note that unless you are very confident in what you are doing, the problem should not be modified in this callback: it should be used to interrogate the problem only.

• call_after_discrete_problem_solve (default=<class 'pyomo.contrib.gdpopt.util._DoNothing'>) –

  Callback called right after the MILP discrete problem is solved. Takes three arguments: The solver object, the discrete problem, and the GDPopt utility block on the discrete problem.

  Note that unless you are very confident in what you are doing, the problem should not be modified in this callback: it should be used to interrogate the problem only.

• call_before_master_solve (default=<class 'pyomo.contrib.gdpopt.util._DoNothing'>) – DEPRECATED: Please use ‘call_before_discrete_problem_solve’

• call_after_master_solve (default=<class 'pyomo.contrib.gdpopt.util._DoNothing'>) – DEPRECATED: Please use ‘call_after_discrete_problem_solve’

• mip_presolve (bool, default=True) – Flag to enable or disable GDPopt MIP presolve. Default=True.

• calc_disjunctive_bounds (bool, default=False) – Calculate special disjunctive variable bounds for GLOA. False by default.

• obbt_disjunctive_bounds (bool, default=False) – Use optimality-based bounds tightening rather than feasibility-based bounds tightening to compute disjunctive variable bounds. False by default.

• mip_solver (default='gurobi') – Mixed-integer linear solver to use. Note that no persistent solvers other than the auto-persistent solvers in the APPSI package are supported.

• mip_solver_args (dict, optional) – Keyword arguments to send to the MILP subsolver solve() invocation

• nlp_solver (default='ipopt') – Nonlinear solver to use. Note that no persistent solvers other than the auto-persistent solvers in the APPSI package are supported.

• nlp_solver_args (dict, optional) – Keyword arguments to send to the NLP subsolver solve() invocation

• minlp_solver (default='baron') – Mixed-integer nonlinear solver to use. Note that no persistent solvers other than the auto-persistent solvers in the APPSI package are supported.

• minlp_solver_args (dict, optional) – Keyword arguments to send to the MINLP subsolver solve() invocation

• local_minlp_solver (default='bonmin') – Mixed-integer nonlinear solver to use. Note that no persistent solvers other than the auto-persistent solvers in the APPSI package are supported.

• local_minlp_solver_args (dict, optional) – Keyword arguments to send to the local MINLP subsolver solve() invocation

• small_dual_tolerance (default=1e-08) – When generating cuts, small duals multiplied by expressions can cause problems. Exclude all duals smaller in absolute value than the following.

• bound_tolerance (NonNegativeFloat, default=1e-06) – Tolerance for bound convergence.

version()

Return a 3-tuple describing the solver version.