L2: Algorithms: Knapsack Problem & BnB

Transcription

1 L2: Algorithms: Knapsack Problem & BnB This tutorial covers the basic topics on creating a forms application, common form controls and the user interface for the optimization models, algorithms and heuristics, and simulation models that will be created in the following tutorials. Secondly, an exact algorithm for the continuous knapsack problem and a heuristic for the integer knapsack problem will be implemented. Finally, the integer knapsack problem will be solved by the Branch-and-Bound (BnB) algorithm that uses the implemented exact algorithm as the solution approach for the continuous relaxation of the integer problem. For a better understanding of the BnB algorithm and related strategies; the iterations will be carried out step by step using the form application created. In the following tutorials, a general BnB algorithm will be implemented to automate these iterations. (Wikipedia) The knapsack problem or rucksack problem is a problem in combinatorial optimization: Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. It derives its name from the problem faced by someone who is constrained by a fixed-size knapsack and must fill it with the most valuable items. Notation I : Set of items. v i : Unit value of item i. w i : Unit weight of item i. W : Total weight capacity of the knapsack l i : Minimum quantity of item i to be placed in the knapsack. u i : Available quantity of item i. x i : Quantity of item i placed in the knapsack (decision variable). Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 1

2 1.1 Mathematical Formulation max v i x i x i I subject to w i x i W, i I l i x i u i, i I. In classical knapsack problems, x i s are integer variables and l i = 0, i I. When x i s are continuous, there exists a polynomial time algorithm that optimally solves the problem. 1.2 Feasibility Condition The knapsack problem is feasible if the following condition is satisfied: l i w i W. i I Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 2

3 1.3 Greedy Algorithm for Continuous Knapsack Problem Let r i = v i /w i, i I, be value-to-weight ratio of item i. The following algorithm optimally solves the knapsack problem when the decision variables are continuous. S0. x i = l i, i I 2 W = l i w i i I 3 V = l i v i i I 4 If W > W then stop. The problem is infeasible. S1. While I do 6 i = argmax{r i } i I W W 7 x i = x i + min {u i l i, } 8 W = W + (x i l i ) w i w i 9 V = V + (x i l i ) v i 10 I = I {i } 11 EndWhile S2. Return x i, W, V. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 3

4 1.4 Greedy Algorithm for Integer Knapsack Problem The operation a rounds down the real number a to the nearest integer. In the integer knapsack problem; we assume that the bounds are integer. The following algorithm provides a polynomial-time discrete solution to the integer knapsack problem; however, the solution is not necessarily optimal. S0. x i = l i, i I 2 W = l i w i i I 3 V = l i v i i I 4 If W > W then stop. The problem is infeasible. S1. While I do 6 i = argmax{r i } i I W W 7 x i = x i + min {u i l i, } 8 W = W + (x i l i ) w i w i 9 V = V + (x i l i ) v i 10 I = I {i } 11 EndWhile S2. Return x i, W, V. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 4

5 STEP 1: Uğur Arıkan ; 5

6 Your program will be crated with a single class, Program.cs; and a single form Form1.cs. To run your program, press the Start button (or F5). You will see an empty form. The program stops when the form is closed. You can manually resize the form using the [Design] view. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 6

7 STEP 1: Click the Toolbox in the left-menu (if you cannot see the Toolbox, click View > Toolbox from the top-menu); select All Windows Forms; drag and drop DataGridView, Label (twice), TextBox, Button (twice), into the form. Uğur Arıkan ; 7

8 2.1 Label (msdn.microsoft.com) Label represents a standard Windows label. STEP 2: Select label1 in the form; right-click and click Properties. In the Properties window, change the Text property from label1 to W. STEP 3: Select label2 in the form; right-click and click Properties. In the Properties window, change: the Name property from label2 to lbloutput, the AutoSize property from True to False. The Label property of a Label control is the text displayed in the form; while the Name property will be used to call the control. Switching the AutoSize property to False allows to edit and fix the size of the control. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 8

9 2.2 TextBox (msdn.microsoft.com) You can both display text and retrieve text from users by using a TextBox control. STEP 4: Select the TextBox in the form; right-click and click Properties. In the Properties window, change the Name property from textbox1 to tbxw. 2.3 Button (msdn.microsoft.com) Button control reacts to the ButtonBase.Click event. STEP 5: Select the button1 in the form; right-click and click Properties. In the Properties window, change: the Name property from button1 to btncont, the Text property from button1 to Continuous. Select the button2 in the form; right-click and click Properties. In the Properties window, change: the Name property from button2 to btnint, the Text property from button2 to Integer. The first button, btncont, will be used to run the Greedy heuristic for the continuous problem; and btnint will be used to run the Greedy heuristic for the integer problem. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 9

10 2.4 DataGridView (msdn.microsoft.com) The DataGridView control provides a powerful and flexible way to display data in a tabular format. You can use the DataGridView control to show read-only views of a small amount of data, or you can scale it to show editable views of very large sets of data. STEP 6: Select the DataGridView in the form; right-click and click Properties. In the Properties window, change the Name property from datagridview1to dgv. In the Properties window, click the button; Edit Columns window will appear. Click Add to add a column for weight (w): Repeat the last step to add columns for value, lower bound, upper bound, and quantity: The DataGridView will be used to get data for the Knapsack problem; and display the solution (x). Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 10

11 STEP 7: Resize the form; resize and relocate the controls properly: Run your program (F5), and check the controls (test adding rows to the DataGridView). Uğur Arıkan ; 11

12 3.1 Data Representation The data of the Knapsack problem can be represented by a list of Item objects; where the Item class holds the variables for weight, value, lower bound, and upper bound. We will also create a field for value-to-weight ratio. STEP 8: Right-click L2 in the Solution Explorer; and click Add > Class; and add the Item class with the following fields, constructor, and methods. The index field will represent the index of the item in the DataGridView, and hence, in the item list. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 12

13 3.2 Code within the Windows Form STEP 9: Right-click Form1.cs in the Solution Explorer; and click View Code. You will see the code of the form class; with a single constructor that uses the generic InitializeComponent method. Notice the inheritance (Form1 : Form) which states that Form1.cs inherits the Form class. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 13

14 To represent the data of the Knapsack problem; we will add a list of Item objects; a double for the capacity W. Finally, we will add a method to read data from the form. STEP 10: Add the following fields and method in Form1.cs. Note that we use the names (tbxw, dgv) to call the controls in the form). tbxw.text returns the user input in the TextBox. this.items = new List<Item>(); creates an empty list of Item objects. Therefore, if the list contained Item objects before the readdata method is called; the list will be cleared at this line. dgv.rows.count returns the number of rows of the DataGridView. The -1 is to eliminate the last empty row of the DataGridView for the new entries. dgv.rows[i].cells[j].value returns the value entered in row i and column j of the DataGridView. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 14

15 3.3 Button Click Event STEP 11: Go back to Form1.cs [Deisgn]; double click on the Continuous button. The method btncont_click will automatically be added in Form1.cs. Add the following line in the method and add a breakpoint at this line (F9): Run the program (F5); add two items and enter the capacity as shown below: Then, click the Continuous button. The program will break at the readdata() line. Press F10 to Step Over (or click F11 to Step Into and check the code line by line). Once the program leaves the readdata() line; check if the data is read correctly (place the cursor on the items and W fields to see their current values). Then, click F5 to run the code and go back to the form. Close the form and remove the breakpoint (F9). Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 15

16 4.1 Greedy Algorithm for Continuous Knapsack Problem STEP 12: Add the code of the Greedy Algorithm for Continuous Knapsack Problem (Section 1.3) in the btncont_click method. Check the equivalence of the code with the algorithm given in Section 1.3. Ws and Vs variables correspond to W and V in the algorithm. // can be used to add comment lines to your code. The line List<Item> list = this.items.orderbydescending(t => t.getr()).tolist(); creates a new list called list of Item objects where the items are ordered in descending order of the values in their r field (getr() method). OrderByDescending (or OrderBy for ascending) is a method for lists that effectively orders objects with respect to the desired field(s). Since the list is ordered; the first item, i.e., list[0], returns the item with maximum value-to-weight ratio. The output is written in lbloutput (infeasible; or W and V values); and in the x column of the DataGridView. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 16

17 STEP 13: Test the code of the Greedy Algorithm for Continuous Knapsack Problem by entering the following inputs and pressing the Continuous button. Update both of the lower bounds as 3; and press the Continuous button. Uğur Arıkan ; 17

18 4.2 Greedy Algorithm for Integer Knapsack Problem STEP 14: Go back to Form1.cs [Deisgn]; double click on the Integer button. The method btnint_click will automatically be added in Form1.cs. Add the readdata() line and the code of the Greedy Algorithm for Integer Knapsack Problem (Section 1.4) in the btncont_click method. Add the following line in the method and add a breakpoint at this line (F9): Note that the only difference is the use of Floor function of the Math library; which is equivalent to the a operation defined in Section 1.4. Also the output message is slightly different. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 18

19 STEP 15: Test the code of the Greedy Algorithm for Integer Knapsack Problem by entering the following inputs and pressing the Integer button. Update both of the lower bounds as 3; and press the Integer button. Uğur Arıkan ; 19

20 (Wikipedia) Branch and bound (BB, B&B, or BnB) is an algorithm design paradigm for discrete and combinatorial optimization problems, as well as general real valued problems. A branch-andbound algorithm consists of a systematic enumeration of candidate solutions by means of state space search: the set of candidate solutions is thought of as forming a rooted tree with the full set at the root. The algorithm explores branches of this tree, which represent subsets of the solution set. Before enumerating the candidate solutions of a branch, the branch is checked against upper and lower estimated bounds on the optimal solution, and is discarded if it cannot produce a better solution than the best one found so far by the algorithm. In this tutorial, we will focus on using the BnB algorithm for solving a program with integer variables where it is efficient to solve the program s continuous relaxation. Notation I : Set of integer variables of the original problem. i, j : Variable index for the integer variables, i, j I. x i : Integer variable, i I. l i : Lower bound of the integer variable x i in the original problem. u i : Upper bound of the integer variable x i in the original problem. N : Set of active nodes in the branch and bound tree. n, m : Node indices for the nodes in the BnB tree; n, m N. z n : Lower bound for the objective function value at node n. l ni : Lower bound for variable x i at node n. u ni : Upper bound for variable x i at node n. z n : Optimal objective function value of the continuous relaxation at node n. z : Best integer solution found during the execution of the algorithm. N : Set of nodes that provides the best integer feasible solution(s). Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 20

21 5.1 The Algorithm The following BnB algorithm finds the optimal solution to a minimization problem with integer variables by sequentially solving its continuous relaxations. S0. z = and N =. 2 Create the root node n with: 3 l ni = l i ; u ni = u i, i I. 4 z n =. 5 N = {n}. S1. While N do 7 Select a node m in N. 8 N = N {m}. 9 Solve the relaxed problem with bounds l mi and u mi. 10 If the relaxation is feasible then 11 z m is the optimal obj. function value of the relaxation at node m. 12 If z m z then 13 x mi is the optimal value of x i in the relaxation at node m. 14 I frac = {i I: x mi Z}. 15 If I frac = then 16 If z m = z then 17 N = N {m} 18 ElseIf z m < z then 19 N = {m} 20 z = z m 21 N = N {n N: z n > z } 22 EndIf 23 ElseIf I frac then 24 Select a variable index j from I frac. 25 Create the child node n with z n = z m and 26 l ni = l mi, u ni = u mi ; i I {j} ; l nj = l mj, u nj = x mj 27 Create the child node n with z n = z m and 28 l n i = l mi, u n i = u mi ; i I {j} ; l n j = x mj, u nj = u mj 29 N = N {n, n}. 30 EndIf 31 EndIf 32 EndIf 33 EndWhile S2. Return z, N. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 21

22 In the initialization step, the following operations are carried out: Since there is no integer feasible solution yet, the best feasible objective function value (z ) is set to and the set of optimal nodes (N ) is initialized as an empty set (line 1). The root node is created (lines 2-4). The root node uses the bounds of the original problem and the best possible objective function value is set to. The node queue is initialized including only the root node (line 5). The algorithm keeps only the nodes that might improve the best feasible objective function value; and the algorithm terminates when no such node exists (line 6). At each iteration of the While loop; a node (m) is selected and removed from the node set N; and the relaxation of the problem with respect to the bounds of this node is solved (lines 7-9). If the relaxation of the problem is infeasible; the discrete version of the problem will certainly be infeasible. In this case, no further operation is needed and the node is eliminated (line 10). If the relaxation is feasible; but the optimal objective function value of the relaxation z m is worse than the best feasible solution found so far; the node is again eliminated (line 12). On the other hand, if z m z ; the node and its children may improve the best solution found so far. In this case we first check the integer feasibility of the solution (line 15). Note that I frac is the set of variable indices for which the variable takes fractional values (Z is the set of integers). Therefore, whenever I frac =, the solution is integer feasible. If an integer feasible solution is found (line 15) at node m; there is no need to create its children. However, its objective function value is compared with the best objective function value found so far. If z m = z ; the node is added to the set of nodes providing the best integer feasible solutions (line 17). On the other hand, if z m < z ; all nodes previously added to N are removed since they cannot be optimal (line 19). The best objective function value is updated (line 20). Moreover, due to the strict improvement in the best objective function value; the nodes in the queue N are checked, as well. In particular, if a node n N has z n > z ; the children of the node cannot lead to an optimal solution. Therefore, such nodes are fathomed (line 21). Finally, whenever the solution of the relaxation is feasible; the optimal objective function value promises improvement z m z ; however the solution of the relaxation is not integer feasible (line 23); two children of node m are created. A variable with fractional value, j, is selected from I frac. Both children of the node (n, n) inherits the lower and upper bounds of the parent (m) except that: u nj = x mj for the node n; and l nj = x mj for the node n (lines 26 and 28). Moreover, the best possible objective function value that these children can lead to is z m. Therefore, we set z n = z n = z m (lines 25 and 27). Finally, these children are added to the queue (line 29). Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 22

23 When the algorithm terminates; n corresponds to the optimal objective function value of the original program with integer variables. Moreover, the continuous relaxations of each node in N provides an optimal solution to the original problem. 5.2 Exercise 1 Note that the Greedy Algorithm for Continuous Knapsack Problem efficiently solves the LP relaxation of the Integer Knapsack problem. Therefore, the optimal solution of the Integer Knapsack problem can be obtained by the BnB algorithm where the continuous algorithm is used to solve the relaxation at the nodes (line 9). Moreover, the Windows Forms Application created in Sections 1-3 can be used to update lower and upper bounds using the DataGridView and get the solution of the relaxations using the Continuous button. STEP 16: The original problem with integer x i variables has the following data: Note that the integer feasible solution obtained by the Greedy Algorithm for Integer Knapsack Problem is 37. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 23

24 STEP 17: Initialization step: 1. z =, N = 2. Create node 0 with l 01 = 0, u 01 = 5; l 02 = 0, u 02 = 3 z 0 = 5. N = {0} First iteration: 7. Select node 0 from N = {0}. 8. N = N {0} = 9. Solve the relaxation (continuous button): 10. Relaxation is feasible. 11. z 0 = z 0 z =. 14. I frac = {1}. 24. Select variable index 1 from I frac. 25. Create lower branch node 1 with l 11 = 0, u 11 = 1; l 12 = 0, u 12 = 3 z 1 = Create upper branch node 2 with l 21 = 2, u 21 = 5; l 22 = 0, u 22 = 3 z 2 = Add the children to the queue: N = N {1,2} = {1,2} Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 24

25 STEP 18: Second iteration: 7. Select node 1 from N = {1,2}. 8. N = N {1} = {2} 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 1 = z 1 z =. 14. I frac =. 18. z 1 < z. 19. N = {1}. 20. z = z 1 = Check whether the nodes in N can be fathomed: N = N {n N: z n > z = 37} = {2} { } = {2} At the second iteration; an integer feasible solution is obtained. However, none of the nodes in N could be fathomed since the node 2 can lead to a better solution (z 2 = 46 z = 37). Note that the solution in this node is the solution obtained by the Greedy Heuristic. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 25

26 STEP 19: Third iteration: 7. Select node 2 from N = {2}. 8. N = N {2} = 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 2 = z 2 z = I frac = {2}. 24. Select variable index 2 from I frac. 25. Create lower branch node 3 with l 31 = 2, u 31 = 5; l 32 = 0, u 32 = 2 z 3 = Create upper branch node 4 with l 41 = 2, u 41 = 5; l 42 = 3, u 42 = 3 z 4 = Add the children to the queue: N = N {3,4} = {3,4} Note that the children inherit the bounds of the parent node (l 31 = l 41 = 2); except for the new bounds on the second variable (u 32 = 2 and l 42 = 3). Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 26

27 STEP 20: Fourth iteration: 7. Select node 3 from N = {3,4}. 8. N = N {3} = {4} 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 3 = z 3 z = I frac = {1}. 24. Select variable index 1 from I frac. 25. Create lower branch node 5 with l 51 = 2, u 51 = 2; l 52 = 0, u 52 = 2 z 5 = Create upper branch node 6 with l 61 = 3, u 61 = 5; l 62 = 0, u 62 = 2 z 6 = Add the children to the queue: N = N {5,6} = {4,5,6} Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 27

28 STEP 21: Fifth iteration: 7. Select node 4 from N = {4,5,6}. 8. N = N {4} = {5,6} 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is infeasible. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 28

29 STEP 22: Sixth iteration: 7. Select node 5 from N = {5,6}. 8. N = N {5} = {6} 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 5 = z 5 z = I frac =. 18. z 5 < z. 19. N = {5}. 20. z = z 5 = Check whether the nodes in N can be fathomed: N = N {n N: z n > z = 38} = {6} { } = {6} Note that the solution in node 1, or the solution of the Greedy Heuristic (z 1 = 37) is not optimal, and hence, the node is removed from N (line 19). Since z 6 = 44 z ; node 6 cannot be fathomed. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 29

30 STEP 23: Seventh iteration: 7. Select node 6 from N = {6}. 8. N = N {6} =. 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 6 = z 6 z = I frac = {2}. 24. Select variable index 2 from I frac. 25. Create lower branch node 7 with l 71 = 3, u 71 = 5; l 72 = 0, u 72 = 1 z 7 = Create upper branch node 8 with l 81 = 3, u 81 = 5; l 82 = 2, u 82 = 2 z 8 = Add the children to the queue: N = N {7,8} = {7,8} Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 30

31 STEP 24: Eighth iteration: 7. Select node 7 from N = {7,8}. 8. N = N {7} = {8}. 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 7 = z 7 z = I frac = {1}. 24. Select variable index 1 from I frac. 25. Create lower branch node 9 with l 91 = 3, u 91 = 3; l 92 = 0, u 92 = 1 z 9 = Create upper branch node 10 with l 10,1 = 4, u 10,1 = 5; l 10,2 = 0, u 10,2 = 1 z 10 = Add the children to the queue: N = N {9,10} = {8,9,10} Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 31

32 STEP 25: Ninth iteration: 7. Select node 8 from N = {8,9,10}. 8. N = N {8} = {9,10} 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is infeasible. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 32

33 STEP 26: Tenth iteration: 7. Select node 9 from N = {9,10}. 8. N = N {9} = {10}. 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 9 = z 9 z = I frac =. 18. z 9 < z. 19. N = {9}. 20. z = z 9 = Check whether the nodes in N can be fathomed: N = N {n N: z n > z = 39} = {10} { } = {10} Since z 10 = 42 z ; node 10 cannot be fathomed. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 33

34 STEP 27: Eleventh iteration: 7. Select node 10 from N = {10}. 8. N = N {10} =. 9. Solve the relaxation (update the bounds and use the continuous button): 10. Relaxation is feasible. 11. z 10 = z 10 z = I frac =. 18. z 10 < z. 19. N = {10}. 20. z = z 10 = Check whether the nodes in N can be fathomed: N = N {n N: z n > z = 40} = { } { } = Since N =, the algorithm terminates at the eleventh iteration. Since N = {10}, the relaxed solution at node 10 is the unique optimal solution to the original integer knapsack problem with x 1 = 4; x 2 = 0 and the optimal objective function value is 40. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 34

35 The BnB tree of the exercise is summarized in the figure below: Uğur Arıkan ; 35

36 5.3 Discussion on BnB Strategies In the Exercise in Section 4.2; we have selected the first element of the set N at each iteration (first-in-first-out). This is not a common strategy. Two classical strategies are best-first and depth first strategies; and a combination of these strategies is commonly used. Depth-first (last-in-first-out) strategy aims to select a node, children of which soon lead to an integer feasible solution. Finding good integer feasible solutions in the early iterations of the algorithm will improve the bounds and help fathom more nodes. On the other hand, best-first strategy selects the node with most promising lower bound. While the strategy is promising to find a good integer feasible solution; the algorithm may require a greater number of iterations to find the initial bounds. Implementing a good node selection strategy is not trivial. There exist heuristics that may help improve the convergence performance of the BnB algorithm. Moreover, problem-specific information might help implementing strategies that work well with the particular problem. In the exercise; we always observed a single variable that attains a fractional value ( I frac 1) due to the nature of the Knapsack problem and the given bounds. However, this is generally not the case; and the modeler needs to decide on which variable to branch on. Implementing a good variable selection strategy is also another nontrivial problem. Finally note that the BnB algorithm might solve a great number of relaxations of the original problem. However, when there exists an efficient approach to solve the relaxed problem; and when node and variable strategies are successfully implemented; the algorithm might converge considerably fast. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 36

37 5.4 Exercise 2 In the next tutorial, we will implement a generic BnB algorithm. Therefore, understanding how the algorithm works and how its strategies affect convergence on a well-known example is important before developing the generic code. Below is the data of another integer knapsack problem to exercise. Think how the steps of the BnB algorithm change when all integer variables of the problem are binary variables; or when some of the integer variables have negative lower bounds. Uğur Arıkan (ugur_arikan@sutd.edu.sg ; 37