SIMPLEX LIKE (aka REDUCED GRADIENT) METHODS. REDUCED GRADIENT METHOD (Wolfe)

Transcription

1 19 SIMPLEX LIKE (aka REDUCED GRADIENT) METHODS The REDUCED GRADIENT algorithm and its variants such as the CONVEX SIMPLEX METHOD (CSM) and the GENERALIZED REDUCED GRADIENT (GRG) algorithm are approximation methods that are similar in spirit to the Simplex method for LP. The reduced gradient method and the CSM operate on a linear constraint set with nonnegative decision variables, while GRG generalizes the procedure to nonlinear constraints, possibly with lower and upper bounds on decision variables. REDUCED GRADIENT METHOD (Wolfe) This is a generalization of the simplex method for LP, to solve problems with nonlinear objectives: Minimize f(x) st Ax b, x. Here we assume that A is an (mn) matrix of rank m, and that b, xr n. At iteration i We have the n decision variables partitioned as BASIC and NON-BASIC, i.e,,, Rank exists Thus (After possible reordering), let, be the current design.

2 191 A requirement for guaranteeing convergence is that no degeneracy is permitted at any iteration, i.e., xb>. If more than m variables are positive at the iteration, then the m largest (positive) variables are selected as the basic variables (assuming their columns are linearly independent). We wish to decrease f(x) while maintaining feasibility. Suppose we change the nonbasic variables by an amount N from xn i, and the basic variables by an amount B from xb i. Then. As xn changes from xn i by N, xb should be changed by B in such a way that the new point x i+1 = x i + is still feasible, i.e., That is, if we change xb by B= -B -1 NN then our new design will satisfy Ax=b. Now consider f (the change in f ) for small : f f T (x i ), f = Bf T (x i )B + Nf T (x i )N () Substituting for B in () above we have:

3 192 f = Bf T (x i )(-B -1 NN) + Nf T (x i )N = {Nf T (x i ) - Bf T (x i )B -1 N}N = [N] T N (say), where [N] T = Nf T (x i ) - Bf T (x i )B -1 N In summary: IF xn changes from xn i by N, AND xb is correspondingly changed from xb i by B to maintain feasibility, THEN f is the change in f. Now, since we are minimizing, we would like to move in the direction -N to decrease f. Let N be the search direction for xn. Then for in, a) If i, i = -i (): we 'increase' xi in the direction -i b) If i, i = -i (): we 'decrease' xi in the direction -i as long as xi >, = if xi = (since we cannot decrease below zero ) As proposed initially by Wolfe, the Reduced Gradient method uses for in i = if i & xi i otherwise The Convex Simplex method (Zangwill) chooses only one axis to move along. Let, = Max {-i i } = Max {xii i } case (a), case (b), = -s (), =xtt ()

4 193 If (1) OR >, = then, N = [ 1 ] T s th position (2) > OR >, = then, N = [ -1 ] T t th position (3) == OR =, = OR =, = then, we have a K-K-T point: STOP! Once we have N, then B = -B -1 NN and Once is determined we do a line search as usual in the direction (by using a one dimensional search procedure like Golden Section, Fibonacci etc.), i.e.,, Min f(x i +), st max, where max = sup { x i +} If this yields *, then x i+1 = x i + * and so on... EXAMPLE (CSM): Min x1 2 x1 x2 st 2x1 + x2 1, x1 + 2x2 1, x1, x2 Adding slack variables we rewrite the constraints as 2x1 + x2 + x3 = 1 x1 + 2x2 + x4 = 1; x1, x2, x3, x4

5 For this problem, f T (x) = 1. Start with x1 = x2 =, x3 = x4=1, f(x )=, and with x3 and x4 in the basis. ITERATION 1:,, (Note that Rank(B)=2) ,,and 1 1,and 1 1 Search Direction: N T Nf T (x ) - Bf T (x )B -1 N = max{+1, +1} = 1; = We could choose N= 1 or 1. Let us choose1... B = -B -1 NN = ; Line Search: Minimize max=sup{, -, (1-2), (1-) } =.5

6 195 Minimize. A line search yields * =.5. Therefore 1/2 x 1 = x + * =, f(x 1 )= /2 In summary, x1 has now entered the basis and replaced x3 (which cannot be in the basis since it has reached its lower bound of zero). ITERATION 2:,, , and ,,and.5.5,and 1 Search Direction: N T Nf T (x 1 ) - Bf T (x 1 )B -1 N = max{+1} = 1; =max ()= Since > we have N= 1. B = -B -1 NN = ;

7 196 Line Search: /2 1 Minimize /2 max=sup{ (1-)/2,, -, (1-3)/2 } = 1/3 Minimize / 1 /2 1/2 A line search yields * =1/3. Therefore 1/3 x 2 = x 1 + * 1/3 =, f(x 2 )= Thus x2 has now entered the basis and replaced x4 ITERATION 3:,, , and 2/3 1/3 1/3 2/3 1/3 1/3,,and 1/3 1/3 1/3 1,and Search Direction: N T Nf T (x ) - Bf T (x )B -1 N 2/3 1/3 1/ /3 2/3 1 1/9 5/9 = max{+1/9} = 1/9; =max (5/9)=

8 197 Since > we have N= 1. 2/3 1/3 B = -B -1 NN = 1/3 2/ /3 1/3 ; 1/3 1 2/3 Line Search: Minimize 1/3 2/3 1/3 1/ /3 1 /3 max=sup{ (1-2), 1+),, - } =.5 Minimize. 1 2/3 1 2/3 1/3 A line search yields * =1/8. Therefore 1/4 x 3 = x 2 + * 3/8 =, f(x 3 )= /8 At this point x4 is definitely nonbasic, we could select any two of the other three to be basic as long as they have linearly independent columns in A; let us (arbitrarily) choose x1 and x2 (same as before). ITERATION 4: Continue and verify that x 3 is the optimum solution...

9 198 The algorithm s progress is as shown below: x2 f= x1+2x2=1 x 3 = x * FEASIBLE REGION x 2 2x1+x2=1 f=-.555 f= f=-.5 x x 1 x1 Path followed by the algorithm

10 GENERALIZED REDUCED GRADIENT (GRG) ALGORITHM GRG (Abadie and Carpentier) is essentially a generalization of the convex simplex method to solve Min f(x) st gj(x) =, j=1,2,...,m, ai xi bi, i=1,2,...,n; xr n. GRG is considered to be one of the better algorithms for solving problems of the above form. 199 SIMILAR IN CONCEPT TO SIMPLEX METHOD FOR LP... SIMPLEX GRG Reduced Costs Reduced Gradients Basic Variables Dependent Variables Nonbasic Variables Independent Variables DIFFERS IN THAT Nonbasic (independent) variables need not be at their bounds, At each iteration, several nonbasic (independent) variables could change values Basis need not change from one iteration to the next.

11 2 At the beginning of each iteration we partition the n decision variables into 2 sets: 1) Dependent variables (one per equation), 2) Independent variables Let (after reordering the variables) Here, xd is a vector of (m) Dependent variables xi is a vector of (n-m) Independent variables Similarly, we partition ; ; rows rows The Jacobian matrix (J) is : : : :, where JD is mm and JI is m(n-m) m cols. (n-m) cols. Note that J has m rows; row i is gi T (x). Let be our current design, where gj(x i ) = j, (x i is feasible) ad < < bd (dependent variables are not at a bound) JD is nonsingular (JD -1 exists) ai bi (independent variables are within their bounds)

12 21 Let be a change vector in the value of x i For small values of, gj = change in gj gj T (x i ). Choose so that x i+1 is still feasible (or to be precise, near-feasible), i.e., choose, 1,2,, : : Since JD(x i ) is nonsingular, [JD(x i )] -1 exists and D = -[JD(x i )] -1 [JI(x i )]I Similarlyfor small values of, f = change in f f T (x i ) f = Df T (x i )D + If T (x i )I () Substituting D in () we have f = Df T (x i ) {-[JD(x i )] -1 [JI(x i )]I} + If T (x i )I = {If T (x i ) - Df T (x i ) [JD(x i )] -1 [JI(x i )] }I i.e., where = If(x i ) - [Df T (x i ) [JD(x i )] -1 [JI(x i )]] T is called the REDUCED GRADIENT VECTOR.

13 22 In other words IF is changed by an amount I, AND is changed by an amount D in order to maintain gj(x) for all j, THEN is the corresponding change in the value of f. Since we are minimizing we want f to be negative. Assuming that i>, (so that -i would correspond to a decrease in xi and +i to an increase), we therefore move in the negative of the direction corresponding to the vector while ensuring that the bounds on xi (namely ai and bi) are not violated. Thus the STEP DIRECTION I for the independent variables has elements given by if if and if and For the dependent variables, if and if and D = -[JD(x i )] -1 [JI(x i )] I can go either way irrespective of the direction of I since ad< xd < bd. Contrast this with the Simplex method for LP where only one independent (nonbasic) variable is changed at each iteration by selecting Max i which doesn't violate a constraint ( the ratio test for the minimum value ).

14 Having found the search direction we do the usual line search (using one of Golden Section, Fibonacci, etc.) to find the step size, i.e., Min f(x i +), st max, where max = sup { ax i +b} Suppose the optimum step size is *. Correction Step In general, we might find that gj(x i + * ) for some j. 23 Therefore, we need a correction step (as in the gradient projection method) to reattain feasibility: x i x i + * correction step x i+1 gj(x)= This is done for example, by fixing the independent variables at the values found and then solving the system g(x)= using x i + * as the initial guess for a Newton- Raphson search. Suppose we write x i + * = [xi, xd] T. Then our problem at this stage is to solve g(xi, y)= by adjusting only y (a system of m equations in m unknowns). We start with y = xd, and Newton s iterations are applied for r=1,2, via y r+1 = y r [JD(xI, y r )] -1 g(xi, y r ) until g(xi, y k )= for some k. We then set xd = y k. Here, JD(xI, y r ) is the Jacobian matrix for the constraint functions evaluated at y=y r for the dependent variables, with the independent variables fixed at xi

15 24 There are three possible pitfalls during the correction step that we must safeguard against: 1. The final feasible solution x i+1 =(xi, xd) might yield a value for f that is worse than what it was at x i. 2. One or more bounds on x are violated during the Newton s iterations 3. The constraint violation actually starts to increase. In all three cases, the typical solution is to reduce the step size along the direction from * to (say) * /2. Now the point x i + * is closer to x i and the Newton iterations are re-executed to obtain a new feasible point x i+1 with f(x i+1 )< f(x i ). This process might need to be repeated more than once x i x i+1 x i + * gj(x)= b2 a2 x i x i+1 x i + * a1 b1 gj(x)=

16 25 Finding Search Directions from the Reduced Gradient vector There are several versions actually for picking I. Let us start by defining S j & ( x ) ( a ), OR & ( x ) ( b ) j I j I j j I j I j Note that S is an index subset of I (the index set of independent variables), denoting variables that (1) we would like to decrease but are already at their lower bounds, or (2) we would like to increase but are already at their upper bounds. if Version 1: (I)j = otherwise (this is the classical version) Version 2: Identify s argmax {MaxjS j } and set if (I)j = if (GRGS) This version coincides with the greedy version of the simplex method for LP where we pick the nonbasic variable with the best reduced cost. Version 3: Cyclically set (I)j = -j for js and all other (I)j =, where a cycle consists of n iterations. (GRGC) In other words, for k=1,2,,n set if (I)j k = if as long as ks and k is not a basic variable. If k is basic or is in S we simply move on to k+1 instead. After k=n we return to k=1 and continue the process.

17 26 GRG and the K-K-T Conditions Recall that with GRG we stop when (i) i for all {i xi=bi}, (ii) i, for all {i xi=ai}, and (iii)i = for all {i xi<bi and xi>ai}. This stopping condition is related to the K-K-T conditions for the original problem: Min f(x) st gj(x)= for j=1,2,,m aixibi for i=1,2,,n Consider the Lagrangian for the above problem: L(x,) = f(x) + jjgj(x) - ii(xi-ai) + ii(xi-bi) At the optimum, the K-K-T conditions yield L = f(x) + j jgj(x) - ( -) =, along with the original constraints;,, and complementary slackness for the bounding constraints. Thus L = f(x) + j jgj(x) - =, where i = i if xi ai i if xi bi if ai xi bi Since we disallow degeneracy and the variables indexed in D are all strictly between their respective bounds this implies that If(x) + JI T (x) - =, and Df(x) + JD T (x) =.

18 27 The second equation yields = -[ JD T (x)] -1 Df(x) Substituting this value for into the first equation yields = If(x) - JI T (x) [JD T (x)] -1 Df(x) = If(x) - JI T (x) [ JD -1 (x)] T Df(x) (since (A T ) -1 =(A -1 ) T ) = If(x) [[JD(x)] -1 JI(x)] T Df(x) (since A T B T =(BA) T ) = If(x) [Df T (x) [JD(x)] -1 JI(x)] T (since A T B=(B T A) T ) Note that this is the same formula we obtained for the reduced gradient vector! Thus the method may be viewed as moving through a sequence of feasible points x k, and in search of a point that yields a vector that satisfies the K-K-T conditions for optimality. This search is done using the above relationship.

19 28 EXAMPLE: Min x1 2 x1 x2 st 2x1 + x2 1, x1 + 2x2 1, x1, x2 Rewriting this in the standard form required for GRG Min f(x) = x1 2 x1 x2 st g1(x) = 2x1 + x2 + x3-1= g2(x) = x1 + 2x2 + x4-1= (ai=) xi 1 (=bi) Note that we could have actually used (½ ) for b1 and b2 in this problem. In cases where the bound is not obvious from the constraints we could use some large value. Let us start with x = [x1 x2 x3 x4 ] T = [¼ ½ ¾] T with f(x ) = -3/16. Let us (arbitrarily) choose x1 and x2 as the independent variables. The requirements are that the point should be feasible with respect to both the constraints and the bounds (which is obviously met), the dependent variables cannot be at either bound (also met), and finally that JD should be nonsingular (also met since JD = 1, which is obviously nonsingular). 1

20 29 ITERATION 1: 1/4, 1/2 3/ ; Thus 1/2 1 and Compute the reduced gradient... = If(x ) - [Df T (x ) [JD(x )] -1 [JI(x )]] T (NOTE: A corresponding step in the Simplex method is the computation of the "cj zj" values; the reduced costs.) 1/ /2 1 This says that the objective function f increases in the direction [-1/2-1] T. Therefore our search should proceed in the opposite direction, i.e., 1/2 1 Γ Γ Note that 2=1 is possible only because x2 is currently at its lower bound of a2 =. If it had been at its upper bound b2 we would have chosen 2= / /2

21 x2 x1+2x2=1 1/ /2.3.2 FEASIBLE REGION 2x1+x2=1.1 f= -3/ x =(1/4, ) (-1/2, -1) LINE SEARCH: We now minimize along the direction of search: Minimize f(x +), st a x + b x1 i.e., Minimize f(x +), st max where max = supremum{ a x + b} 1/4 /2 1/41/2 1 1/ /2 2 1/22 1 1/2 3/4 5/2 3/4 5/2 13/4 maxmin (1.5, 1,.25,.3) =.25 Hence the line search is. 1/4 /2 1/2 2 3/4 5/2

22 211. 1/4 /2 1/4 / This could be done by a line search procedure such as Fibonacci, GSS, quadratic interpolation, etc. It is easily shown that the optimum is at * =.25. Thus we have: 1/4 1/2 3/8 1/ /4 ; 2 3/4 5/2 1/8 31/64 Checking for feasibility, we see that x 1 is feasible; so we need not make any correction step (in general, this will be true here because we have all linear constraints...) The current point is shown below: x f= -3/16 x1+2x2=1 f= -31/64 FEASIBLE REGION x 1 = (3/8, 1/4) 2x1+x2= x =(1/4, ) x1

23 212 At the point x 1, x3 has reached its lower bound. Recall that a dependent variable (such as x3) cannot be at a bound. We must therefore make x3 independent and remove it from xd and place it in xi. The old partition was I={1,2} and D={3,4}.Since neither independent variable is currently at a lower bound, we could choose either x1 or x2 to replace, as long as the resulting JD is. Let us (arbitrarily) choose to replace x1. Thus D={1,4} and I={2,3}. ITERATION 2: 3/8 1/4 1/8 ; /4, 3/8 1/8 1/4 ; ; Recompute the reduced gradient: and 1/2 1/2 1 = If(x 1 ) - [Df T (x 1 ) [JD(x 1 )] -1 [JI(x 1 )]] T 1 1/2 1/4 1/ /8 1/8 This says that in order to decrease f, our search direction should be 7/8 1/8 Γ Γ.

24 213 BUT while x2=1/4 implies that we can increase it, the fact that x3= implies that we CANNOT decrease it; it is already at its lower bound of a3=! THEREFORE 7/8, and since we are only looking for a direction, we could simplify matters by choosing Γ Γ 1. Then Γ Γ 1/2 1/ /2 3/2 LINE SEARCH: We now minimize along the direction of search: x x1+2x2=1 f= -31/64 FEASIBLE REGION 1/2 1 3/2 (steepest descent direction) x 1 = (3/8, 1/4) 2x1+x2=1.1 f x =(1/4, ) x1

25 214 Minimize f(x 1 +), st a x 1 + b i.e., Minimize f(x 1 +), st max where max = supremum{ a x 1 + b} 3/8 /2 3/81/2 13/8 1/4 1/41 1 1/4 1 1/8 3/2 1/8 3/2 11/8 maxmin (3/4,3/4,-,1/12) = 1/12 Hence the line search is / 3/8 /2 1/4 1/8 3/2 / * =1/12. (VERIFY ). Thus 3/8 1/2 1/3 1/4 1 1/3 ; 1/8 3/2 5/9 Checking for feasibility, we see that x 2 is feasible; so we need not make any correction step... Again, note that a dependent variable (x4) has reached its (lower) bound of a4 =. Therefore we must once again repartition...

26 215 x x1+2x2=1 f= -3/16 f= -31/64 FEASIBLE REGION f= -5/9 x 2 = (1/3, 1/3) x 1 = (3/8, 1/4) 2x1+x2= x =(1/4, ) x1 The old partition was I={1,4} and D={2,3}. We must choose either x3 or x2 to replace x4. However x3 is already at its (lower) bound so it cannot be made dependent. Therefore, we replace x2 by x4. Our new partition is D={1,2} and I={3,4} ITERATION 3: 1/3 1/3 ;, 1/3 1/ /3 1 ; ; 1 1 and 2/3 1/3 1/3 2/3

27 216 Recompute the reduced gradient: = If(x 2 ) - [Df T (x 2 ) [JD(x 2 )] -1 [JI(x 2 )]] T 2/3 1/3 1 1/3 1/3 2/ /9 5/9 Thus, to decrease f, we must move in the direction - and Hence and (a) Increase x3:this is OK since x3= currently (b) Decrease x4: this is not allowed because x4=a4 = Γ Γ 1/9 1. Γ Γ 2/3 1/3 1/3 2/ /3 1/3 CONTINUE AND VERIFY THAT YOU GET THE SAME OPTIMAL SOLUTION OBTAINED BY THE CONVEX SIMPLEX METHOD...

28 217 SEPARABLE PROGRAMMING DEFINITION: A function f(x1,x2,...,xn) is SEPARABLE if it can be written as a sum of terms, with each term being a function of a SINGLE variable: EXAMPLES,,, NOT SEPARABLE SEPARABLE 5 / log 2log 3 6 although this could be separated as log x + 2(log y) PIECE-WISE LINEAR (SEPARABLE) PROGRAMMING Let 1, 2, be "weights" such that jj=1, j for all j. If we have a convex function f(z), we have for any z given by z = 1z 1 + 2z kz k, f(z) 1f(z 1 ) + 2f(z 2 ) kf(z k ) each z i is a GRID POINT z 1 z 2 z z 3 z 4

29 In general, any z has many representations in terms of the z k. Consider z=1.75 = 7/4, with f(z)=1.5, and four grid points z =, f(z )=2; z 1 =1, f(z 1 )=1; z 2 =2, f(z 2 )=2; and z 3 =3, f(z 3 )=5: f(z) f(z) z z =5/12, 3=7/12, 1=2=; f(z) =5/8, 3=3/8, =2=; f(z) f(z) f(z) z z 1=1/2, 2=1/4, 3=1/4, =; f(z) =1/4, 2=3/4, =3=; f(z) 1.75

30 219 Notice that in all cases the approximation to f(z) is always greater than the true value of f(z) (=1.5). However, the specific combination of grid points that yields the lowest (and hence the best) value for the approximation is the one which uses only the two ADJACENT grid points. The problem Min f(z), st g(z) could now be approximated as Min k k f(z k ) st k k g(z k ); k k =1, k k. This is an LP Problem in the variables! Furthermore, in the optimal set of values, AT MOST two j values will be positive and these will be ADJACENT. Question: What if f(z) is NOT convex? z 1 z 2 z 3 z 4 z 5 z 6 In that case, the property above will not necessarily hold; a "RESTRICTED BASIS ENTRY" rule must be enforced to "force" adjacent points in order to get a good approximation.

31 22 EXAMPLE Maximize 2x1 x1 2 + x2 st 2x x2 2 6; x1, x f =2.5 f =2.213 f = FEASIBLE REGION x1 * =.796 x2 * = Thus the problem is Max f1(x1) + f2(x2) = {2x1 x1 2 } + { x2} st g1(x1) + g2(x2) = {2x1 2 } + {3x2 2 } 6 Suppose we use the 9 grid points (,.25,.5,.75, 1., 1.25, 1.5, 1.75, 2.) for approximating f1and g1; and the same 9 grid points for approximating f2 and g2. k x1 f1 g1 k x2 f2 g

32 g1(x1) = 2x f1(x1) = 2x1 x g2(x2) = 3x f2(x2) = x Assuming weights k and k respectively for the gridpoints corresponding to x1 and x2, the PIECE-WISE LINEAR approximation yields the following LP: Maximize st 6 1, =1; k,bk for all k. Max st ( ) 4+ ( ) = 1, = 1; k,bk for all k.

33 222 Thus we have a linear program in 18 variables and 3 constraints. The OPTIMAL SOLUTION to this LP is =1, k * = for k3; and = , =.99..., k * = for k5,6, with an objective function value of Reconstructing the original problem, we have, x1 * = 1(.75) =.75, x2 * =.999 (1.25) +.99 (1.5) = , with f(x * ) = , which compares quite favorably with the true optimum, x1 * =.796, x2 * = 1.258, with f(x * ) = The piece-wise LP approach and separable programming are somewhat "specialized" in nature, with limited general applicability. Often, one could try and INDUCE separability... For example: Term Substitution Extra Constraints Restrictions x1x2 x1x2 = y1 y2 y1=(x1+x2)/2 -- y2=(x1- x2)/2 x1x2 x1x2 = y log y = log x1 +log x2 x1, x2 > log y = (x1 + x2 2 ) --

34 223 FRACTIONAL PROGRAMMING The linear fractional programming problem is: Minimize, st, This has some interesting properties: 1. If an optimum solution exists, then an extreme point is an optimum (cf LP) 2. Every local minimum is also a GLOBAL minimum Thus we could use a simplex like approach of moving from one extreme point to an adjacent one. The most obvious approach is Zangwill's convex simplex algorithm that we saw earlier, which simplifies here into a minor modification of the Simplex method for LP. The direction finding and step size subproblems are considerably simplified. Other fractional programming algorithms include the ones developed by Gilmore and Gomory, and Charnes and Cooper. Refer to Bazaraa, Sherali and Shetty for example, for more details...