We're always happy to welcome work with additional collaborators and contributors. One of the easy ways for newcomers to contribute is by adding additional relaxations.
If you're interested in contributing in larger ways, please contact: Matthew Wilhelm
If you have any requests for additional functionality, bug fixes, or comments please feel free to open a new issue using Github issue tracker.
(X,P) space into a series of boxes that all contain unique branches of the implicit function p->y(p).EAGO.McCormick.implicit_relax_h! — Function.implicit_relax_h!Relaxes the implicit function determined by h(x,p) with x in X and p in P. The reference point for the affine relaxations is pmid. The parameters generated from the relaxation at pmid are param and the basic parameters of the fixed point method are mc_opt.
EAGO.McCormick.implicit_relax_fg — Function.implicit_relax_fgRelaxes the functions f(x,p) and g(x,p) by relaxation the state variable x using the implicit function determined by h(x,p) with x in X and p in P. The reference point for the affine relaxations is pmid. The parameters generated from the relaxation at pmid are param and the basic parameters of the fixed point method are mc_opt.
EAGO.McCormick.implicit_relax_f — Function.implicit_relax_fRelaxes the function f(x,p) by relaxation the state variable x using the implicit function determined by h(x,p) with x in X and p in P. The reference point for the affine relaxations is pmid. The parameters generated from the relaxation at pmid are param and the basic parameters of the fixed point method are mc_opt.
EAGO.McCormick.affine_exp! — Function.affine_exp!Computates the affine relaxations of the state variable. Inputs are:
x: State variable relaxationp::Vector{MC{N,T}}: Decision variable relaxationp_ref::Vector{MC{N,T}}: Reference variable relaxationxa::Vector{MC{N,T}}: Lower affine relaxation of the state variablexA::Vector{MC{N,T}}: Upper affine relaxation of the state variablez::Vector{MC{N,T}}: Affine function in Xnx: Number of state variableslambda: Convex coefficient used to define z as a function of xa, xAPopulats the following vectors with results (xa,xA,z):
xa::Vector{MC{N,T}}: Lower affine relaxation of the state variablexA::Vector{MC{N,T}}: Upper affine relaxation of the state variablez::Vector{MC{N,T}}: Affine function in XEAGO.McCormick.correct_exp! — Function.correct_exp!Corrects the relaxation of the state variable x_mc if the affine relaxation, 'z_mc', exceeds the interval bounds xL or xU.
z_mc::Vector{MC{N}}: Affine relaxationx_mc::Vector{MC{N}}: Relaxation of state variableX::Vector{IntervalType}: Lower bound on state vectornx::Int64: Size of the state vectorepsv::Float64: Tolerance for checking that subgradient exceeds boundEAGO.McCormick.final_cut — Function.final_cutAn operator that cuts the x_mc object using the x_mc_int bounds in a differentiable or nonsmooth fashion to achieve a composite relaxation within x_mc_int.
EAGO.McCormick.gen_expansion_params! — Function.gen_expansion_params!Generates the relaxations at pref_mc that can be subsequentially used to compute affine relaxations for use in relaxing the implicit function.
EAGO.McCormick.mc_dense_krawczyk_cw! — Function.mc_dense_krawczyk_cw!Performs a single step of the dense-krawczyk componentwise parametric method after the inputs have been preconditioned.
EAGO.McCormick.mc_dense_newton_gs! — Function.mc_dense_newton_gs!Performs a single step of the dense-newton gauss-siedel parametric method after the inputs have been preconditioned.
EAGO.McCormick.pmc_kernel! — Function.pmc_kernel!Peforms the following steps in sequence:
h!(H, x, xp, p, t) in place with x = z_mc, p = p_mc,xp = xp_mc, t = flt_param and preconditions H using an interval midpoint preconditioner if precond = true.
hj!(J, x, xp, p, t) in place with x = aff_mc, p = p_mc,xp = xp_mc, t = flt_param and preconditions J using an interval midpoint preconditioner if precond = true.
contractor if cntr = :Newton and the componentwise Krawczyk contractor otherwise.
The operators currently supported are listed below. The operators with a check box have been subject to a large degree of scrutiny and have been implemented for both forward and reverse McCormick relaxations.
Arbitrarily differentiable relaxations can be constructed for the following operators:
Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported:
The following bivariant operators are supported for two MC objects. Both nonsmooth and Whitney-1 (once differentiable) relaxations are supported.
Arbitrarily differentiable relaxations can be constructed for the following operators:
Arbitrarily differentiable relaxations can be constructed for the following operators:
EAGO provides a library of McCormick relaxations in native Julia code. It supports relaxing functions using both nonsmooth McCormick relaxations (Mitsos2009), smooth McCormick relaxations (Khan2017), multi-variant McCormick relaxations (Tsoukalas2014), as well as subgradient-based interval refinement (Najman2017). For functions with arbitrarily differentiable relaxations, the differentiable can be modified by adjusting a constant value. Additionally, and nonvalidated validated interval bounds are supported via ValidatedNumerics.jl.
EAGO.McCormick.MC — Type.MCMC{N, T <: RelaxTag} <: Real is the McCormick (w/ (sub)gradient) structure which is used to overload standard calculations. The fields are:
cc::Float64: Concave relaxationcv::Float64: Convex relaxationcc_grad::SVector{N,Float64}: (Sub)gradient of concave relaxationcv_grad::SVector{N,Float64}: (Sub)gradient of convex relaxationIntv::Interval{Float64}: Interval boundscnst::Bool: Flag for whether the bounds are constantEAGO.McCormick.RelaxTag — Type.RelaxTagAn abstract type the subtypes of which define the manner of relaxation that will be performed for each operator applied to the MC object. Currently, the struct NS which specifies that standard (Mitsos 2009) are to be used is fully supported. Limited support is provided for differentiable McCormick relaxations specified by struct Diff (Khan 2017) and struct MV struct MV (Tsoukalas 2011.)
EAGO.McCormick.MC — Method.MC{N,T}(y::Interval{Float64})Constructs McCormick relaxation with convex relaxation equal to y.lo and concave relaxation equal to y.hi.
MC{N,T}(y::Float64)Constructs McCormick relaxation with convex relaxation equal to y and concave relaxation equal to y.
MC{N,T}(cv::Float64, cc::Float64)Constructs McCormick relaxation with convex relaxation equal to cv and concave relaxation equal to cc.
MC{N,T}(val::Float64, Intv::Interval{Float64}, i::Int64)Constructs McCormick relaxation with convex relaxation equal to val, concave relaxation equal to val, interval bounds of Intv, and a unit subgradient with nonzero's ith dimension of length N.
In order to bound a function using a McCormick relaxation. You first construct structure that bounds the input variables then you construct pass these variables two a function.
In the example below, convex/concave relaxations of the function f(x)=sin(2x)+exp(x)-x are calculated at x = 1 on the interval [-2,3].
using EAGO, IntervalArithmetic
-
-# create MC object for x = 2.0 on [1.0,3.0] for relaxing
-# a function f(x) on the interval Intv
-
-f(x) = x*(x-5.0)*sin(x)
-
-x = 2.0 # value of independent variable x
-Intv = Interval(1.0,4.0) # define interval to relax over
-
-# create McCormick object
-xMC = MC{1,NS}(x,Intv,1)
-
-fMC = f(xMC) # relax the function
-
-cv = fMC.cv # convex relaxation
-cc = fMC.cc # concave relaxation
-cvgrad = fMC.cv_grad # subgradient/gradient of convex relaxation
-ccgrad = fMC.cc_grad # subgradient/gradient of concave relaxation
-Iv = fMC.Intv # retrieve interval bounds of f(x) on IntvThe plotting the results we can easily generate visual the convex and concave relaxations, interval bounds, and affine bounds constructed using the subgradient at the middle of X.
If we instead use the constructor xMC = MC{1,Diff}(x,Intv,1) in the above code, and then re-plot we arrive at the below graph
set_diff_relax!(1)
This can readily be extended to multivariate functions as shown below
-f(x) = max(x[1],x[2])
-
-x = [2.0 1.0] # values of independent variable x
-Intv = [Interval(-4.0,5.0), Interval(-5.0,3.0)] # define intervals to relax over
-
-# create McCormick object
-xMC = [MC{2,Diff}(x[i], Intv[i], i) for i=1:2)]
-
-fMC = f(xMC) # relax the function
-
-cv = fMC.cv # convex relaxation
-cc = fMC.cc # concave relaxation
-cvgrad = fMC.cv_grad # subgradient/gradient of convex relaxation
-ccgrad = fMC.cc_grad # subgradient/gradient of concave relaxation
-Iv = fMC.Intv # retrieve interval bounds of f(x) on Intv
This component is meant to provide a flexible framework for implementing spatial branch-and-bound based optimization routines in Julia. All components of the branch-and-bound routine can be customized by the individual user: lower bounding problem, upper bounding problem.
EAGO.NodeBB — Type.NodeBBStores information associated with each node in Branch & Bound tree.
lower_variable_bounds::Vector{Float64}: Lower bounds of variable box.upper_variable_bounds::Vector{Float64}: Upper bounds of variable box.lower_bound::Float64: Lower bound of problem solution on nodeBBupper_bound::Float64: Upper bound of problem solution on nodeBBdepth::Int64: Depth of node in B&B tree.id::Int64: Unique id for each node.EAGO.add_cut! — Method.add_cut!(t::ExtensionType, x::Optimizer)Adds a cut for each constraint and the objective function to the subproblem.
EAGO.branch_node! — Method.branch_node!(t::ExtensionType, x::Optimizer)Creates two nodes from currentnode using information available the x and stores them to the stack. By default, relative width bisection is perfomed at a point `branchpntwhich is a convex combination (parameter: branch_cvx_factor) of the solution to the relaxation and the midpoint of the node. If this solution lies withinbranchoffset/widthof a bound then the branch point is moved to a distance ofbranchoffset/width` from the bound.
EAGO.convergence_check — Method.convergence_check(t::ExtensionType, x::Optimizer)Checks for convergence of algorithm with respect to absolute and/or relative tolerances.
EAGO.cut_condition — Method.cut_conditioncut_condition(t::ExtensionType, x::Optimizer)Checks if a cut should be added and computes a new reference point to add the cut at. If no cut should be added the constraints not modified in place are deleted from the relaxed optimizer and the solution is compared with the interval lower bound. The best lower bound is then used.
EAGO.fathom! — Method.fathom!(t::ExtensionType, d::Optimizer)Selects and deletes nodes from stack with lower bounds greater than global upper bound.
EAGO.lower_problem! — Method.lower_problem!(t::ExtensionType, x::Optimizer)Constructs and solves the relaxation using the default EAGO relaxation scheme and optimizer on node y.
EAGO.relax_objective! — Method.relax_objective!(t::ExtensionType, x::Optimizer, x0::Vector{Float64})A rountine that only relaxes the objective.
EAGO.relax_problem! — Method.relax_problem!(t::ExtensionType, x::Optimizer, v::Vector{Float64}, q::Int64)A rountine that updates the current node for the Evaluator and relaxes all nonlinear constraints and quadratic constraints.
EAGO.node_selection! — Method.node_selection!(t::ExtensionType, x::Optimizer)Selects node with the lowest lower bound in stack.
EAGO.optimize_hook! — Method.optimize_hook!(t::ExtensionType, x::Optimizer)Provides a hook for extensions to EAGO as opposed to standard global, local, or linear solvers.
EAGO.postprocess! — Method.postprocess!(t::ExtensionType, x::Optimizer)Default postprocess perfoms duality-based bound tightening on the y.
EAGO.preprocess! — Method.preprocess!(t::ExtensionType, x::Optimizer)Runs interval, linear, quadratic contractor methods followed by obbt and a constraint programming walk up to tolerances specified in EAGO.Optimizer object.
EAGO.repeat_check — Method.repeat_check(t::ExtensionType, x::Optimizer)Checks to see if current node should be reprocessed.
EAGO.single_storage! — Method.single_storage!(t::ExtensionType, x::Optimizer)Stores the current node to the stack after updating lower/upper bounds.
EAGO.termination_check — Method.termination_check(t::ExtensionType, x::Optimizer)Checks for termination of algorithm due to satisfying absolute or relative tolerance, infeasibility, or a specified limit, returns a boolean valued true if algorithm should continue.
EAGO.upper_problem! — Method.upper_problem!(t::ExtensionType, x::Optimizer)Default upper bounding problem which simply calls solve_local_nlp! to solve the nlp locally.
EAGO.cut_update — Method.cut_update(x::Optimizer)Updates the internal storage in the optimizer after a valid feasible cut is added.
EAGO.default_nlp_heurestic — Method.default_nlp_heurestic(x::Optimizer, y::NodeBB)Default check to see if the upper bounding problem should be run. By default, The upper bounding problem is run on every node up to depth upper_bounding_depth and is triggered with a probability of 0.5^(depth - upper_bounding_depth) afterwards.
EAGO.interval_bound — Function.interval_boundComputes the natural interval extension of a MathOptInterface function s or ScalarQuadaraticFunction on a node y. Returns the lower bound if flag is true and the upper bound if flag is false.
EAGO.interval_lower_bound! — Method.interval_lower_bound!(x::Optimizer, y::NodeBB)A fallback lower bounding problem that consists of an natural interval extension calculation. This is called when the optimizer used to compute the lower bound does not return a termination and primal status code indicating that it successfully solved the relaxation to a globally optimal point.
EAGO.is_globally_optimal — Method.is_globally_optimal(t::MOI.TerminationStatusCode, r::MOI.ResultStatusCode)Takes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns the tuple (valid_result::Bool, feasible::Bool). The value valid_result is true if the pair of codes prove that either the subproblem solution was solved to global optimality or the subproblem solution is infeasible. The value of feasible is true if the problem is feasible and false if the problem is infeasible.
EAGO.is_feasible_solution — Method.is_feasible_solution(t::MOI.TerminationStatusCode, r::MOI.ResultStatusCode)Takes an MOI.TerminationStatusCode and a MOI.ResultStatusCode and returns true if this corresponds to a solution that is proven to be feasible. Returns false otherwise.
EAGO.log_iteration! — Method.log_iteration!(x::Optimizer)If 'loggingon' is true, the 'globallowerbound', 'globalupperbound', 'runtime', and 'nodecount' are stored every 'loginterval'. If 'logsubprobleminfo' then the lower bound, feasibility and run times of the subproblems are logged every 'log_interval'.
EAGO.same_box — Method.same_box(x::NodeBB,y::NodeBB, atol::Float64)Checks that node x and y have equal domains withing a tolerance of atol.
EAGO.solve_local_nlp! — Method.solve_local_nlp!(x::Optimizer)Constructs and solves the problem locally on on node y updated the upper solution informaton in the optimizer.
EAGO.set_dual! — Method.set_dual!(x::Optimizer)Retrieves the lower and upper duals for variable bounds from the relaxed_optimizer and sets the appropriate values in the _lower_lvd and _lower_uvd storage fields.
EAGO.update_relaxed_problem_box! — Method.update_relaxed_problem_box!(x::Optimizer, y::NodeBB)Updates the relaxed constraint by setting the constraint set of v == x*,xLi <= xi, andxi <= xUi` for each such constraint added to the relaxed optimizer.
EAGO.print_iteration! — Function.print_iteration!Prints the iteration information based on verbosity. The header is displayed every header_interval, the iteration info is displayed every iteration_interval.
EAGO.print_node! — Function.print_node!Prints node information for the B&B problem. Node id, bound, and interval box.
EAGO.print_results! — Function.print_results!Prints the results of a single bounding problem.
EAGO.print_solution! — Function.print_solution!Prints solution information for the B&B problem. Displays first node found, solution value, solution, and time spent solving subproblems.
Variable bound tightening based on the duality multipliers are supported.
EAGO.variable_dbbt! — Function.variable_dbbt!Tightens the bounds of the _current_node using the current global upper bound and the duality information obtained from the relaxation.
Bound tightening for linear forms, univariate quadratic forms, and bivariate quadratic forms are also supported.
EAGO.classify_quadratics! — Function.classify_quadratics!Classifies constraints as univariate or bivariate and adds them to storage vectors.
EAGO.lp_bound_tighten — Function.lp_bound_tightenPerforms the linear bound tightening.
EAGO.univariate_kernel — Function.univariate_kernelKernel of the bound tightening operation on univariant qudaratic functions. Called for each univariate function.
EAGO.univariate_quadratic — Function.univariate_quadraticPerforms bound tightening on all univariate quadratic functions.
EAGO contains a constraint propagation architecture that supported forward and reverse evaluation of set-valued functions on the directed acyclic graph (DAG). The interval contractor and reverse McCormick relaxation-based contractors are currently available.
EAGO.cpwalk — Function.cpwalkPerforms forward-reverse pass on directed graph as part of constraint propagation.
EAGO makes use of an optimization-based bound tightening scheme using filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4
EAGO.aggressive_filtering! — Function.aggressive_filtering!Excludes OBBT on variable indices after a search in a filtering direction.
EAGO.aggressive_obbt_on_heurestic — Function.aggressive_obbt_on_heuresticRoutine that determines if aggressive filtering should be used. Currently, a user-specified option.
EAGO.bool_indx_diff — Function.bool_indx_diffUtility function used to set vector of booleans z to x & ~y. Avoids the generation of conversion of the BitArray created by broadcasting logical operators.
EAGO.obbt — Function.obbtPerforms OBBT with filtering and greedy ordering as detailed in: Gleixner, A.M., Berthold, T., Müller, B. et al. J Glob Optim (2017) 67: 731. https://doi.org/10.1007/s10898-016-0450-4
EAGO.trivial_filtering! — Function.trivial_filtering!Excludes OBBT on variable indices that are tight for the solution of the relaxation.
By default, EAGO uses GLPK for solving linear subproblems introduced. Using a commercial linear solver is highly recommended such as Gurobi, CPLEX, or XPRESS is highly recommended. Both Gurobi and CPLEX are free for academics and installation information can be found through http://www.gurobi.com/academia/academia-center and https://www.ibm.com/developerworks/community/blogs/jfp/entry/CPLEXIsFreeForStudents?lang=en, respectively.
A non-default LP solver can then be selected by the user via a series of keyword argument inputs as illustrated in the code snippet below. The relaxed_optimizer contains an instance optimizer with valid relaxations that are made at the root node and is updated with affine relaxations in place. Options can be passed to this optimizer using keyword arguments when initializing EAGO using the withoptimizer syntax in JuMP by defining an Iterators.Pairs structure assigning it to the `relaxedoptimizer_kwargs` keyword argument. MOI.
-# Create opt EAGO Optimizer with CPLEX for use with MOI routines
-opt = EAGO.Optimizer(relaxed_optimizer = Gurobi.Optimizer(OutputFlag=0))
-
-# Create the same model m using an options dictionary in JuMP
-relaxed_optimizer_kwargs = Dict{Symbol, Any}()
-opt_dict[:relaxed_optimizer] = Gurobi.Optimizer()
-opt_dict[:relaxed_optimizer_kwargs] = Iterators.Pairs([:OutputFlag], [0])
-
-m = JuMP.Model(with_optimizer(EAGO.Optimizer; opt_dict...))
-
-# Create the same model m is keyword arguments in JuMP
-m = JuMP.Model(with_optimizer(EAGO.Optimizer; relaxed_optimizer = Gurobi.Optimizer(),
- relaxed_optimizer_kwargs = Iterators.Pairs([:OutputFlag], [0])))Ipopt is the recommended solver for upper bounding problems. Ipopt's performance is highly dependent on the linear algebra package used (up to 30x). By default MUMPS is used. It's recommended that you either compile Ipopt with HSL MA57 or the Pardiso linear algebra packages with a machine specific Blas library (for Intel users the JuliaPro MKL version is recommended). For information on this, see the below links:
The EAGO.Optimizer object holds all algorithm solution information. A description of all user-facing options has been provided in the docstring.
EAGO.Optimizer — Type.OptimizerThe main optimizer object used by EAGO to solve problems during the optimization routine. The following commonly used options are described below and can be set via keyword arguments in the JuMP/MOI model:
presolve_scrubber_flag::Bool: Replace code in user-defined functions which may prevent method overloading on Real subtypes (default = false).presolve_to_JuMP_flag::Bool: Create and use DAG representations of user-defined function (default = false).presolve_epigraph_flag::Bool: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Apply the epigraph reformulation to the problem (default = false).presolve_cse_flag::Bool: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Enable common subexpression elimination for DAG (default = false).presolve_flatten_flag::Bool: Rerranges the DAG using registered transformations (default = false)cp_depth::Int64: Depth in B&B tree above which constraint propagation should be disabled (default = 1000).cp_repetitions::Int64: Number of repetitions of forward-reverse passes to perform in constraint propagation (default = 3).cp_tolerance::Float64: Disable constraint propagation if the ratio of new node volume to beginning node volume exceeds this number (default = 0.99).cp_interval_only::Bool: Use only valid interval bounds during constraint propagation (default = false).relaxed_optimizer::S: An instance of the optimizer used to solve the relaxed subproblems (default = GLPK.Optimizer()).relaxed_optimizer_kwargs::Base.Iterators.Pairs: Keyword arguments for the relaxed optimizer.obbt_depth::Int64: Depth in B&B tree above which OBBT should be disabled (default = 1000).obbt_repetitions::Int64: Number of repetitions of OBBT to perform in preprocessing (default = 3).obbt_aggressive_on::Bool: Turn aggresive OBBT on (default = false).obbt_aggressive_max_iteration::Int64: Maximum iteration to perform aggresive OBBT (default = 2)obbt_aggressive_min_dimension::Int64: Minimum dimension to perform aggresive OBBT (default = 2)obbt_tolerance::Float64: Tolerance to consider bounds equal (default = 1E-9).obbt_variable_values::Vector{Bool}: Variables to perform OBBT on (default: all variables in nonlinear expressions).lp_depth::Int64: Depth in B&B tree above which linear FBBT should be disabled (default = 1000).lp_repetitions::Int64: Number of repetitions of linear FBBT to perform in preprocessing (default = 3).quad_uni_depth::Int64: Depth in B&B tree above which univariate quadratic FBBT should be disabled (default = -1).quad_uni_repetitions::Int64: Number of repetitions of univariate quadratic FBBT to perform in preprocessing (default = 2).quad_bi_depth::Int64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Depth in B&B tree above which bivariate quadratic FBBT should be disabled (default = -1).quad_bi_repetitions::Int64: Number of repetitions of bivariate quadratic FBBT to perform in preprocessing (default = 2).subgrad_tighten::Bool: Perform tightening of interval bounds using subgradients at each factor in each nonlinear tape during a forward-reverse pass (default = true).subgrad_tighten_reverse::Bool: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Used to enable/disable subgradient tightening of interval bounds on the reverse pass (default = true).cut_max_iterations::Int64cut_cvx::Float64: Convex coefficient used to select point for new added cuts. Branch point is given by (1-cut_cvx)*xmid + cut_cvx*xsol (default = 0.9).cut_tolerance::Float64: Add cut if the L1 distance from the prior cutting point to the new cutting point normalized by the box volume is greater than the tolerance (default = 0.05).objective_cut_on::Bool: Adds an objective cut to the relaxed problem (default = true).upper_optimizer::T: Optimizer used to solve upper bounding problem (default = Ipopt.Optimizer())upper_factory::JuMP.OptimizerFactory: OptimizerFactory used to build optimizer that solves the upper bounding problem (default = with_optimizer(Ipopt.Optimizer, kwargs), check Optimizer constructor for kwargs used).upper_bounding_depth::Int64: Solve upper problem for every node with depth less than upper_bounding_depth and with a probability of (1/2)^(depth-upperboundingdepth) otherwise (default = 4).dbbt_depth::Int64: Depth in B&B tree above which duality-based bound tightening should be disabled (default = 1E10).dbbt_tolerance::Float64: New bound is considered equal to the prior bound if within dbbt_tolerance (default = 1E-9).branch_cvx_factor::Float64: Convex coefficient used to select branch point. Branch point is given by branch_cvx_factor*xmid + (1-branch_cvx_factor)*xsol (default = 0.25)branch_offset::Float64: Minimum distance from bound to have branch point normalized by width of dimension to branch on (default = 0.15)branch_variable::Vector{Bool}: Variables to branch on (default is all nonlinear).branch_max_repetitions::Int64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Number of times repeat node processing prior to branching (default = 4).branch_repetition_tol::Float64: [FUTURE FEATURE, NOT CURRENTLY IMPLEMENTED] Volume ratio tolerance required to repeat processing the current node (default = 0.9).rounding_mode::Symbol: Interval rounding mode to use (default = :accurate)node_limit::Int64: Node limit (default = 10^7).time_limit::Float64: Time limit in seconds (default = 3600).iteration_limit::Int64: Iteration limit (default = 3000000).absolute_tolerance::Float64: Absolute tolerance for terminatin (default = 1E-3).relative_tolerance::Float64: Relative tolerance for terminatin (default = 1E-3).local_solve_only::Bool: Perform only a local solve of the problem (default = false).log_on::Bool: Turns logging on records global bounds, node count and run time. Additional options are available for recording information specific to subproblems (default = false).log_subproblem_info::Bool: Turns on logging of times and feasibility of subproblems (default = false).log_interval::Int64: Log data every log_interval iterations (default = 1).verbosity::Int64: The amount of information that should be printed to console while solving values range from 0 - 4: 0 is silent, 1 shows iteration summary statistics only, 2-4 show varying degrees of details about calculations within each iteration (default = 1).output_iterations::Int64: Display summary of iteration to console every output_iterations (default = 10).header_iterations::Int64: Display header for summary to console every output_iterations (default = 100).enable_optimize_hook::Bool: Specifies that the optimize_hook! function should be called rather than throw the problem to the standard B&B routine (default = false).ext::Dict{Symbol, Any}: Holds additional storage needed for constructing extensions to EAGO (default = Dict{Symbol,Any}).ext_type::ExtensionType: Holds an instance of a subtype of EAGO.ExtensionType used to define new custom subroutines (default = DefaultExt()).EAGO.VariableInfo — Type.VariableInfoA structure used to store information related to the bounds assigned to each variable.
is_integer::Bool: Is the variable integer valued?lower_bound::Float64: May be -Inf even if haslowerbound == truehas_lower_bound::Bool: Implies lower_bound == Infupper_bound::Float64: May be Inf even if hasupperbound == truehas_upper_bound::Bool: Implies upper_bound == Infis_fixed::Bool: Implies lowerbound == upperbound and !haslowerbound and !hasupperbound.EAGO.ExtensionType — Type.ExtensionTypeAn abstract type the subtypes of which are associated with functions method overloaded for for new extensions. An instance of the DefaultExt <:ExtensionType structure to the Optimizer in the ext_type field.
EAGO.Log — Type.LogA structure used to store information on the history of the solution procedure for generating convergence plots and other analysis.
current_lower_bound::Vector{Float64}: Storage for lower bound calculated for current node.current_upper_bound::Vector{Float64}: Storage for upper bound calculated for current node.preprocessing_time::Vector{Float64}: Storage for preprocessing time of each iteration.lower_problem_time::Vector{Float64}: Storage for lower bounding time of each iteration.upper_problem_time::Vector{Float64}: Storage for upper bounding time of each iteration.postprocessing_time::Vector{Float64}: Storage for postprocessing time of each iteration.preprocessing_feas::Vector{Bool}: Storage for preprocessing feasibility of each iteration.lower_problem_feas::Vector{Bool}: Storage for lower bounding feasibility of each iteration.upper_problem_feas::Vector{Bool}: Storage for upper bounding feasibility of each iteration.postprocessing_feas::Vector{Bool}: Storage for postprocessing feasibility of each iteration.global_lower_bound::Vector{Float64}: Storage for best (global) lower bound at each iteration.global_upper_bound::Vector{Float64}: Storage for best (global) upper bound at each iteration.Functionality has been included that allows for extension's to EAGO's optimizer to readily be defined. This can be done in two ways first defining a new structure which is a subtype of EAGO.ExtensionType and overloading methods associated with this new structure. An instance of this new structure is provided to the EAGO.Optimizer using the ext_type keyword. This results in EAGO now dispatch to the new methods rather than the generally defined methods for the parent type. For a complete example, the reader is directed to the interval bounding example and quasiconvex example. Alternatively, the user can overload the optimize_hook! for this subtype which will entirely circumvent the default global solution routine. Additional information can be stored in the ext field of EAGO. In order to allow for compatibility between packages the user is encouraged to append their extension name to the start of each variable name (e.g. newext_newdata).
EAGO.relax_convex_kernel — Function.relax_convex_kernelStores the kernel of the calculation required to relax convex quadratic constraints using the immutable dictionary to label terms.
EAGO.relax_nonconvex_kernel — Function.relax_nonconvex_kernelStores the kernel of the calculation required to relax nonconvex quadratic constraints using the immutable dictionary to label terms.
EAGO.relax_quadratic_gen_saf — Function.relax_quadratic_gen_safDefault routine for relaxing nonconvex quadratic constraint lower < func < upper on node n. Takes affine bounds of convex part at point x0 and secant line bounds on concave parts.
EAGO.relax_quadratic! — Function.relax_quadratic!Relaxes all quadratic constraints in x optimizer.
EAGO.relax_nlp! — Function.relax_nlp!A rountine that relaxes all nonlinear constraints excluding constraints specified as quadratic.
EAGO.objective_cut_linear! — Function.objective_cut_linear!Adds linear objective cut constraint to the x.relaxed_optimizer.
EAGO.FunctionSetStorage — Type.FunctionSetStorageA storage object for both set and number valued data required to compute relaxations which contains the tape used to compute a nonlinear function. The object is parameterized by a {N,T<:RelaxTag} where N corresponds the subgradient size used in the MC object.
EAGO.SubexpressionSetStorage — Type.SubexpressionSetStorageA storage object for both set and number valued data required to compute relaxations which contains the tape used to compute a nonlinear subexpression. The object is parameterized by a {N,T<:RelaxTag} where N corresponds the the subgradient size used in the MC object.
EAGO.Evaluator — Type.EvaluatorMOI.AbstractNLPEvaluator for calculating relaxations of nonlinear terms.
EAGO.set_current_node! — Method.set_current_node!(x::Evaluator, n::NodeBB)Sets the current node in the Evaluator structure.
EAGO.eval_objective_lo — Method.eval_objective_loRetrieves the lower bound of the objective.
EAGO.eval_constraint_cc — Method.eval_constraint_cc(d::Evaluator, g::Vector{Float64}, y::Vector{Float64})Populates g with the concave relaxations of the constraints of d evaluated at y.
EAGO.eval_constraint_lo! — Method.eval_constraint_lo!(d::Evaluator, g::Vector{Float64})Populates g with the lower bounds of the constraints of d.
EAGO.eval_constraint_hi! — Method.eval_constraint_hi!(d::Evaluator, g::Vector{Float64})Populates g with the upper bounds of the constraints of d.
EAGO.eval_constraint_cc_grad — Method.eval_constraint_cc_grad(d::Evaluator, g, y)Populates g with the subgradients of the constraints of d evaluated at y.
EAGO.get_node_lower — Method.get_node_lower(d::FunctionSetStorage, i::Int64)Retreives the lower bound of ith term in the tape of d.
EAGO.get_node_upper — Method.get_node_upper(d::FunctionSetStorage, i::Int64)Retreives the upper bound of ith term in the tape of d.
EAGO.forward_reverse_pass — Method.forward_reverse_pass(d::Evaluator, x::Vector{Float64})Performs a d.fw_repeats forward passes of the set-value evaluator each followed by a reverse pass if d.has_reverse as long as the node between passes differs by more that d.fw_atol at each iteration.
Matthew Wilhelm Department of Chemical and Biomolecular Engineering, University of Connecticut
-In [1,2], a surrogate ANN model of bioreactor productivity was constructed by fitting results from computationally expensive CFD simulations. The author then optimized this surrogate model to obtain ideal processing conditions. This - optimization problem is given by:
- -using JuMP, EAGO
-
-# Box constraints for input variables
-xLBD = [0.623 0.093 0.259 6.56 1114 0.013 0.127 0.004]
-xUBD = [5.89 0.5 1.0 90 25000 0.149 0.889 0.049]
-
-# Weights associated with the hidden layer
-W = [ 0.54 -1.97 0.09 -2.14 1.01 -0.58 0.45 0.26;
- -0.81 -0.74 0.63 -1.60 -0.56 -1.05 1.23 0.93;
- -0.11 -0.38 -1.19 0.43 1.21 2.78 -0.06 0.40]
-
-# Weights associated with the output layer
-D = [-0.91 0.11 0.52]
-
-# Bias associated with the hidden layer
-B1 = [-2.698 0.012 2.926]
-
-# Bias associated with the output layer
-B2 = -0.46We now formulate the problem using standard JuMP[3] syntax and optimize it. Note that we are forming an NLexpression object to handle the summation term to keep the code visually simple but this could be placed directly in the JuMP - expressions instead.
-# Model construction
-model = Model(with_optimizer(EAGO.Optimizer, absolute_tolerance = 0.001))
-@variable(model, xLBD[i] <= x[i=1:8] <= xUBD[i])
-@NLexpression(model, prop[i=1:3], B1[i] + sum(W[i,j]*x[i] for j in 1:8))
-@NLobjective(model, Max, B2 + sum(D[i]*(2/(1+exp(-2*prop[i]))) for i=1:3))
-
-# Solves the model
-optimize!(model)We then recover the objective value, the solution value, and termination status codes using standard JuMP syntax.
-# Access calculated values
-fval = JuMP.objective_value(model)
-xsol = JuMP.value.(x)
-status_term = JuMP.termination_status(model)
-status_prim = JuMP.primal_status(model)
-
-println("EAGO terminated with a status of $status_term and a result code of $status_prim")
-println("The optimal value is: $fval, the solution found is $xsol.")EAGO has included basic functionality to manipulate user-defined functions. These features are largely experimental and we're interested in providing additional for novel use cases. Please contact us by opening an issue in the Github issue tracker with any questions or requests for additional features.
EAGO.Script.dag_flattening! — Function.dag_flattening!Flattens (usually) the dag by making all registered substitutions for every nonlinear term in the Optimizer.
EAGO.Script.flatten_expression! — Function.flatten_expression!Flattens (usually) the dag by making all registered substitutions for the expression expr::_NonlinearExprData. Performs a depth-first search through the expression adding the terminal node to the stack, then checking to determine if it matches a registered substitution pattern. If it doesn't not then node is added to the new expression graph representation and it's children are added to the queue. If an expression (node) is identified as a pattern then it is substituted and any children expression nodes are then checked for patterns until the depth first search is exhausted.
EAGO.Script.register_substitution! — Function.register_substitution!Specifies that the src::Template_Graph should be subsituted out for the trg::Template_Graph.
Conventions for substition, the expression to be checked always appears at key 1 in the Template_Graph and operations are ordered from low value to high value left to right so if 1 is a -, and 4 => 1, 3 => 1 then the expression is 4 - 3
EAGO.Script.Template_Graph — Type.Template_GraphHolds a list of Template_Nodes, set of directed edges, lengths, an adjacency matrix and the number of children.
EAGO.Script.Template_Node — Type.Template_NodeA structure which holds a symbol indicating whether the node is an operator, a number, or an expression type, a value which identifies the function or symbol value, potentially a numeric value num_value, and a check that can be run to verify the node is correct check.
EAGO.Script.scrub — Function.scrub(f::Function, n::Int, inplace = false)Replaces storage objects and circumvents assertions that present a UDF from being overloaded with subtype Real objects by creating a function which overdubs f in ScrubCtx.
EAGO.Script.scrub! — Function.scrub!(d::_NLPData)Applies scrub to every user-defined function in the a _NLPData structure.
Matthew Wilhelm Department of Chemical and Biomolecular Engineering, University of Connecticut
-Semi-infinite programming remains an active area of research. In general, the solution of semi-infinite programs with nonconvex semi-infinite constraints of the below form are extremely challenging:
-
- EAGO implements the SIPres of [1] to determine a globally optimal solution to problems of the above form. This accomplished using the explicit_sip_solve function which returns the optimal value, the solution, and a boolean
- feasibility value. To illustrate the functions use, a simple example is presented here which solves the below problem:
- using EAGO, JuMP
-
-# Define semi-infinite program
-f(x) = (1/3)*x[1]^2 + x[2]^2 + x[1]/2
-gSIP(x,p) = (1.0 - (x[1]^2)*(p[1]^2))^2 - x[1]*p[1]^2 - x[2]^2 + x[2]
-
-x_l = [-1000.0, -1000.0]
-x_u = [1000.0, 1000.0]
-p_l = [0.0]
-p_u = [1.0]
-
-# Solve the SIP problem
-sip_result = explicit_sip_solve(x_l, x_u, p_l, p_u, f, gSIP)
-
-println("The global minimum of the semi-infinite program is between: $(sip_result.lower_bound) and $(sip_result.upper_bound).")
-println("The global minimum is attained at: x = $(sip_result.xsol).")
-println("Is the problem feasible? (sip_result.feasibility).")EAGO.explicit_sip_solve — Function.explicitsipsolve
-Solve an SIP with decision variable bounds x_l to x_u, uncertain variable bounds p_l to p_u, an objective function of f, and gSIP seminfiniite constraint(s).
EAGO.SIPProblem — Type. SIPProblemStructure storing problem information for the solution routine.
-EAGO.SIPResult — Type. SIPResultStructure storing the results of the SIPres algorithm.
-A paper about the EAGO software package is currently under preparation. In the meantime, please feel free to cite the conference presentation below:
Wilhelm, Matthew; Stuber, Matthew (October 2017) Easy Advanced Global
-Optimization (EAGO): An Open-Source Platform for Robust and Global Optimization
-in Julia. Presented at the AIChE Annual Meeting in Minneapolis, MN.Number of results: loading...