B553 Lecture 12: Global Optimization

Transcription

1 B553 Lecture 12: Global Optimization Kris Hauser February 20, 2012 Most of the techniques we have examined in prior lectures only deal with local optimization, so that we can only guarantee convergence a global solution when only one local optimum exists. We have also seen metaheuristic methods like simulated annealing and genetic algorithms that only achieve probabilistic guarantees of converging to an optimum. In this lecture we ask, can a global minimum of general nonlinear functions be found with stronger guarantees? This turns out to be extremely challenging, particularly when many variables are involved. In fact, we have already seen that a relatively simple version of this problem quadratic programming with an indefinite Hessian matrix is NP hard. As always, exhaustive search is one possibility, but is very inefficient in high-dimensional spaces (O(1/h n ), where h is the grid resolution). The main method we will cover in this class, branch-and-bound optimization, cannot do better in the worst case. However, it can certainly perform better in practice while still attaining the same guarantees on global optimality. We will only cover a few other techniques briefly. 1 Branch and Bound Optimizations Branch-and-bound methods take the approach of recursively subdividing the initial feasible set S 0 into smaller and smaller subsets S 1, S 2,..., and finding the minima of each subset (this is the branch portion of the method). Simultaneously, they use some auxiliary procedure to determine upper and lower bounds on the minimum across an entire subset. If the lower bound of some S k is higher than the best upper bound, then it can be pruned from further subdivision. This continues until the sets are smaller than some tolerance ɛ x. 1

2 Although branch-and-bound methods can be applied to continuous optimization they can be quite effective for combinatorial and mixed-integer optimization as well. In fact most commercial MILP solvers use some form of branch-and-bound method alongside other specialized techniques. 1.1 Algorithm The algorithm is as follows: 1. Q {S 0 }. 2. f f(x) for some point x S While Q is not empty, do: 4. Remove some item S from Q. 5. If LowerBound(S) f go to step Otherwise, f min(f, f(x)) for some point x S 7. If S is larger than the threshold ɛ x, partition S into S 1,..., S k and add them to Q. 8. Return f. This algorithm stores a queue Q of subsets of S 0 that are remaining to be considered. It also stores the best function value f seen so far. Note that the value f(x) of any point in S is an upper bound on min x S f(x). As it progressively subdivides the space, the algorithm uses an auxiliary function LowerBound to compute a lower bound on min x S f(x). [It is important to note that the upper bound is not an upper bound on the value of f over S, but rather the minimum over S. Make sure you understand the difference.] The performance of this method is determined by how many of the partitions are pruned by Line 5. This requires the lower bounds to be tight (i.e., larger), because tighter lower bounds will prune more than loose ones. For example, the trivial lower bound LowerBound(S) = prunes nothing, while the exact lower bound LowerBound(S) = min x S f(x) quickly prunes away much of the feasible set from further consideration. Of course, solving for an exact lower bound is circular, so in practice we settle for lower bound functions with tightness in between these two extremes. At the very least, the bound should become increasingly tight as S shrinks. Note that LowerBound must be provided, and it depends very much on how f is specified. Below we will look at one common way of generating lower bound functions for a large class of f functions. The other part of the problem is lowering the values of f as quickly 2

3 as possible. There are two design decisions that can help accomplish this: 1) finding good points at which to evaluate f(x) in Line 6, 2) partitioning subsets well, or 3) picking a good ordering of the sets in Q. For the first decision, we can either choose an arbitrary point (e.g., the center of S) or try to improve f by doing something more sophisticated. For example, we might solve a similar but simpler optimization problem over S. However, unless the lower bounds are fairly tight the advantages of producing improved upper bounds typically have a marginal impact. For the second decision, it is challenging to make sophisticated partitions that have any reasonable effect on computation time outside of very special cases. Typically, S is maintained as an axis-aligned bounding box, and splits are either performed through bisection on the longest dimension (most typical), or sometimes by partitioning in all dimensions. Most important is the third decision: picking a good ordering of Q. Typically, every S in Q is ordered in increasing value of the lower bound or the upper bound, because these subsets are more likely to contain the true minimum. A final note is that to reduce the overhead involved in maintaining a priority queue, the algorithm can be implemented as a depth-first search with priority given to lower-valued partitions. However, this greedy approach may ultimately be more expensive than the priority queue approach because it may visit many suboptimal branches in order to complete the recursion in a given subtree. 1.2 Generating Lower Bounds using Interval Arithmetic The LowerBound procedure can be defined by hand for some specific objective functions using detailed analysis of the problem structure. However, this is often labor-intensive and may not be worth the effort except in common classes of objective functions. Instead, it is often useful to use interval arithmetic to automatically derive bounds on the function value. Primitive operations. Interval arithmetic extends the four common arithmetic operations +,,, and to interval-valued operands of the form [a, b]. These operations are defined in such a way that the resulting interval [a, b] [c, d] is guaranteed to contain the value of x y for any x [a, b] and y [c, d]. Note that division by any interval containing 0 actually produces two disjoint intervals. Because each operation can be computed in constant 3

4 time given the endpoints of each interval, so we can perform sequences of several basic operations and get an interval in return (or multiple intervals, if divisions by zero are allowed). Other basic operations can be written in interval form as well, such logarithms, exponentiation, and sines and cosines. Most interval arithmetic libraries provide a large list of primitive operations. Interval extensions. For any function f(x) written as a formula of primitive operations, finding an interval that contains the range {f(x) x [a, b]} is then a simple matter of replacing the primitive operations with their interval counterparts. For global optimization, the LowerBound procedure is then taken simply to be the lower end of this interval. The question remains whether this construction works well? It turns out that the interval extension of a given function may not be tight given a particular formula. This occurs when multiple terms in the formula are dependent on the same variable, because intermediate intervals do not maintain any information about how they depend on input variables. For example, consider the function f(x) = x 2 x (1) over the range [0,1]. With this formulation, the interval containing the x 2 term becomes [0, 1]. Then, x, which has the range [0, 1], is subtracted from this interval, giving the final interval [ 1, 1]. This differs significantly from the exact range, [ 1/4, 0]! In practice, interval estimation errors are typically compounded as the function becomes more complex. Part of the art of employing interval methods successfully is to rewrite formulae so that the same variable appears in as few terms as possible. For example, the above equation can be written as f(x) = (x 1/2) 2 1/4 (2) in which x only appears once. In this case, the x 1/2 term is evaluated to [ 1/2, 1/2]. Squared, it becomes [0, 1/4], and after subtracting 1/4 it gives the exact range. For complex objective functions it can be time-consuming to devise such reformulations. 2 Other global optimization methods Structured search methods. If it is known that optima follow some property (e.g., must be at a feasible set vertex, in the case of negative-definite 4

5 quadratic programming) then it is more effective to search among the solutions satisfying that property rather than exhaustively. Homotopy methods. Homotopy methods first construct a simple function for which all the stationary points are known, and then interpolate toward the desired function as a parameter λ changes from 0 to 1. The set of stationary points of the interpolated function are tracked using local optimizations as λ changes. As λ changes, the set of stationary points may undergo many changes: appearing, disappearing, splitting, and coalescing. Homotopy methods have different strategies for discovering each of these potential changes. Relaxation methods. These methods use the structure of the problem to construct a sequence of simpler sub problems, whose solutions converge toward the optimum or a small set that is guaranteed to contain the optimum. For example, the cutting-plane methods used in mixed integer linear programming are a form of relaxation method. 3 Exercises 1. Consider a branch and bound optimization with the objective function f(x) = x 2 over the range [0, 1] n. How many times will f be evaluated to reach the tolerance ɛ x, if the exact upper and lower bounds for each subset of [0, 1] n are computed? Assume that the each subset is maintained as an axis-aligned box and bisected on the longest axis (if many axes are the same, pick one arbitrarily). 2. Compute by hand the interval extension of the function f(x, y) = x 3 (y 2) for x [ 2, 2] and y [1, 3]. Do the same for f(x, y) = y/x. Do the same for { xy if y 2 f(x, y) = (3) xy otherwise. 5