Solving the Hard Knapsack Problems with a Binary Particle Swarm Approach

Transcription

1 Solving the Hard Knapsack Problems with a Binary Particle Swarm Approach Bin Ye 1, Jun Sun 1, and Wen-Bo Xu 1 School of Information Technology, Southern Yangtze University, No.1800, Lihu Dadao, Wuxi, Jiangsu , P.R. China yebinxie@yahoo.com.cn, sunjun wx@hotmail.com, xwb@sytu.edu.cn Abstract. Knapsack problems are important NP-Complete combinatorial optimization problems. Although nearly all the classical instances can be solved in pseudo-polynomial time nowadays, yet there are a variety of test problems which are hard to solve for the existing algorithms. In this paper we propose a new approach based upon binary particle swarm optimization algorithm (BPSO) to find solutions of these hard knapsack problems. The standard PSO iteration equations are modified to operate in discrete space. Furthermore, a heuristic operator based on the total-value greedy algorithm is employed into the BPSO approach to deal with constrains. Numerical experiments show that the proposed algorithm outperforms both the existing exact approaches and recent state-of-the-art search heuristics on most of the hard knapsack problems. 1 Introduction The well-known NP-complete knapsack problem (KP) is defined as: given a set of items with corresponding unit profits p j and unit weights w j,alongwitha knapsack capacity limit c, selects a subset of the items such that the total profit is maximized with the total weight not exceeding c. It can be assumed, without lose of generality, that all profits and weights are positive, that all weights are smaller than the knapsack capacity c and that the total weight exceeds the capacity. By introducing the binary decision variable x j,withx j = 1 if item j is selected, and x j = 0 otherwise, the classical 0/1 knapsack problem can be formulated as: n maximize p j x j subject to j=1 n w j x j c with x j {0, 1}, j=1,...,n. j=1 In the last few decades, many exact or heuristic techniques have been proposed to solve the knapsack problems. The exact algorithms include dynamic D.-S. Huang, K. Li, and G.W. Irwin (Eds.): ICIC 2006, LNBI 4115, pp , c Springer-Verlag Berlin Heidelberg 2006

2 156 B. Ye, J. Sun, and W.-B. Xu programming [1,2] and branch-and-bound [3,4], while the heuristic search procedures focusing on solving the problem approximately include tabu search [5], genetic algorithm (GA) [6,7] and other randomized methods. A good overview of all recent exact approaches can be seen in [8]. It is shown that although the existing algorithms are capable of solving nearly all the KP instances cited in the existing literature within reasonable time, there are two groups of new test KP problems which are hard to solve. For the first group of difficult instances with large coefficients the running times of the dynamic programming algorithms are unacceptably high, while for the other group containing six categories of structurally instances with small coefficients the branch-and-bound algorithms perform badly. In this paper a novel BPSO algorithm is developed to solve the hard knapsack problems. A heuristic operator converting infeasible solutions into feasible solutions is applied to deal with the knapsack constrains. The procedure of the operator is based on the total-value heuristic which picks the item that contributes the highest total profit given the remaining knapsack capacity at each stage. In order to test the BPSO algorithm thoroughly, we adopt the technique in [8] to construct test instances. The experimental results of three different types of algorithms are compared with ours. The rest of the paper is organized as follows. In Section 2, a brief introduction of PSO is given. Then a binary particle swarm algorithm for knapsack problems are proposed in Section 3. Section 4 presents the generation of the two groups of difficult instances and the performance comparison of our algorithm and the most recent algorithms on the instances. A set of conclusions are given in Section 5. 2 Particle Swarm Optimization The particle swarm optimization was originally invented for the function optimization in continuous real-number spaces by Kennedy and Eberhart [9]. A review of its recent approaches to global optimization problems is presented in [10]. In a PSO model, a potential solution is represented as a particle with position X id and velocity V id in a D-dimensional space. Each particle maintains a record of the position with best fitness value the particle experienced so far, called personal best position or Pbest. Each particle share its Pbest with its neighborhoods, so there is a global best solution Gbest. Ateachsearchiteration, the ith particle moves according to the following equations: V id = V id + α (Pbest id X id )+β (Gbest d X id ) (1) X id = X id + V id (2) where α and β are random numbers whose upperbounds determine the influence of Pbest and Gbest. In order to improve the performance of the original PSO algorithm, some revised versions of PSO algorithm are proposed. One of the approaches is to introduce inertia weight ω into (1), so (1) is substituted by V id = ω V id + α (Pbest id X id )+β (Gbest d X id ). (3)

3 Solving the Hard Knapsack Problems 157 A BPSO algorithm which operates in discrete space has been developed in [11]. But this BPSO algorithm is susceptible to function saturations, which occur when velocity values are either too large or too small. A technique using angle modulation to reduce the complexity of binary problems is proposed in [12]. Though efficient it leaves the discrete constraint satisfaction problems untouched. We will present our BPSO algorithm based on the inertia weight PSO model in the next section. 3 A BPSO Algorithm for KP 3.1 Representation Like GA, the first step in implementing a BPSO algorithm is to design a scheme to denote individuals. Since the decision variable x j is binary, it is an obvious choice to represent a solution using an n-bit binary string, where n is the number of items in the KP. Thus each particle s position and velocity in our algorithm are initialized as n-bit binary-coded random vectors. 3.2 Iteration Equations Before presenting the iteration equations, we begin with introducing some new operators to be applied in our proposed BPSO. In a binary space, a particle moves to nearer or farther corners of the hypercube (searching space) by flipping bits in its position vector. So the distance between a particle s current position and its previous best position (in (3) denoted as Pbest id X id ofthedth dimension) can be stated by a vector whose bit is 1 if the alleles of X i and Pbest i are different and sets to 0 otherwise. For example, a particle s current position and its previous best position are: X : (10011) Pbest: (00011) so the distance will be (10000) since the first bits in the two vectors are different. From this simple example, it can be observed that the distance is the output of the binary XOR function which takes X and Pbestas its two inputs. In this way, the operation Pbest id X id in (3) will be substituted with Pbest id X id. Similarly, the distance between a particle s current position and the global best position will be evaluated by Gbest X i. From (3), it can be seen that a particle s velocity at iteration t+1 is primarily determined by three elements: the velocity at iteration t, the distance between X i and Pbest and the distance between X i and Gbest. Since the functions of the three elements (also vectors) are to reverse the corresponding bits in the position vector consistently, they can be united into one vector. Consequently,

4 158 B. Ye, J. Sun, and W.-B. Xu this procedure is implemented using the OR operation. Here is an example: supposing the three elements are A : (10001) B : (01000) C : (00100) respectively, then the velocity will be V = A + B + C = (11101). A particle s position vector will be updated at the next step using the velocity vector. If any bit in the velocity vector is 1, the allele in the position vector will be reversed. And this operation is a equivalence of binary XOR function. This can be illustrated by going on with the previous example. With a arbitrary position vector being (10000), the updated position vector will be (01101) at next iteration. As a result, a particle in a binary space moves according to the following equations: V id = ω V id + α (Pbest id X id )+β (Gbest d X id ) (4) X id = X id V id (5) where inertia weight ω is generally set to less than 1.0. α and β are called acceleration coefficients used to control the convergence speed of the algorithm. Based on the previous work in [13], we have set the typical parameters for a population of 50, the inertia weight ω of 0.729, α of 1.49 and β of Constraints Handling Obviously, the solutions generated by (4) may not be feasible because one of the knapsack constraints may be violated. To deal with constraints, a number of standard ways are proposed. Comparing their performance through preliminary experiments, we adopt in our BPSO the approach of using a heuristic operator to convert an infeasible solution to a feasible one. The heuristic operator is traditionally based on a density-ordered greedy algorithm which picks the item with the highest unit profit to unit weight ratio at each stage. Instead of using the density-ordered greedy algorithm, our heuristic operator is based on a total-value greedy algorithm in which the item with highest profit will be selected if its weight does not exceed the remaining knapsack capacity at each stage. It has been shown that the total-value greedy heuristic dominates the density-ordered greedy algorithm with regard to both the worstcase performance and the average-case performance [14]. Our heuristic operator is constituted of two phases: the drop phase and the add phase. The drop phase is implemented as follows. Once a solution X i = (x 1,x 2,...,x n ) generated by BPSO is infeasible, first calculate its redundancy weight n j=1 (w jx j c) (bigger than zero obviously). Then, among the items picked in the infeasible solution, find out the subset of items with the weight of each item is smaller than the redundancy weight. Throw out the items one by one in the subset with ascent order in weight until the solution becomes feasible.

5 Solving the Hard Knapsack Problems 159 The add phase aim to improve the fitness of a feasible solution. Given the remaining knapsack capacity, the add phase continue to add the item with the largest profit among the items that are not included in the solution and whose weights are smaller than the remaining knapsack capacity until feasibility is violated. 3.4 Algorithm Outline The general steps in our algorithm are described as follows: initialize each particle with a random position and velocity; initialize t_max; while t<t_max { for i=1:population size { if a solution is infeasible { make the solution feasible; } calculate fitness value; } find Pbest and Gbest; updating each particle s position according to (4,5); } 4 Computational Experiments In order to test our algorithm for the knapsack problem more thoroughly, we will analyze its performance in terms of both efficiency and accuracy. Efficiency is a measure of the time required to complete the search and accuracy is what evaluates the quality of the solutions obtained. The test instances we use for measurements are some of the instances from [8], which contains a large variety of instances types. The performance for different instance types and data ranges of our approach is compared with that of the GA [6] and two well-known exact approaches, namely Expknap [4] and Minknap [1]. Two groups of difficult instances are considered in our experiments. One group consists of the traditional instances with larger coefficients; and the other group includes instances with small coefficients, but where present algorithms perform badly. The first group make the dynamic programming algorithm run slower while the second group mainly challenge the branch-and-bound algorithms. 4.1 Difficult Instances with Large Coefficients Six types of traditional data instances are briefly described below. Because the traditional test instances with small data range are too easy to draw any meaningful conclusions, we choose each type with data range R=10 6 and 10 7 for different problem sizes (i.e. n=100, 500, 1000, 5000 and 10000) for testing. Uncorrelated instances (uncorr.): The weights w j and the profits p j are chosen randomly in [1,R].

6 160 B. Ye, J. Sun, and W.-B. Xu Weakly correlated instances (weak corr.): The weights w j are distributed in [1,R] and the profits p j in [w j R/10,w j + R/10] such that p j 1. Strongly correlated instances (str. corr.): The weights are chosen in [1,R]and the profits are set to p j = w j + R/10. Inverse strongly correlated instances (inv. str. corr.): The profits p j are chosen in [1,R]andw j = p j + R/10. Almost strongly correlated instances (al. st. corr.): The weights w j are distributed in [1,R] and the profits in [w j + R/10 R/500,w j + R/10 + R/500]. Subset-sum instances (sub.sum): The weights w j are distributed in [1,R]and p j = w j. In order to eliminate the capacity-dependency of the performances, we choose the capacity in each instance as c = h for instance number h =1, 2,...,1000. We test all the instances on an Intel Pentium 4, 2.9GHz with 256M RAM. The average execution time for each instance type, which is also the average time the BPSO takes for all the 1000 instances, is calculated. Table 1-3 gives the results for the three algorithms. For each instance type, if not all instances are solved in a time limit of 30 minutes or space limit, it is marked with a in the table. Best-so-far values searched in 50 runs by our algorithm and GA during the same time period are compared in Table 4. A typical run for GA is set for a probability of crossover of 0.8; a probability of mutation of 0.01; and a population of 50 (same as the population in our BPSO algorithm). In each run we choose the time limit of 10 minutes as the stopping conditions for GA and our BPSO. It is clear that our BPSO algorithm has a stable performance on all the instance types whereas the exact algorithm Expknap can solve only a few instances within the given time or space limit. For the dynamic programming algorithm Minknap, the average execution time for the strongly correlated and the inverse strongly correlated instances grow to run out of the time limit due to the rapid increasing of the computational complexity. From the results in Table 4, it can be observed that the near-optimal solutions obtained by our BPSO algorithm are more closer to the optimal solution than those obtained by GA for a majority of instances. n j=1 4.2 Difficult Instances with Small Coefficients The following are some difficult instances with small coefficients. The capacity is chosen as in the previous section. The outcomes are summarized in Table 5-7. Spanner instances(v,m): The weights w k of a set of v items (the spanner set) are chosen in [1,R] randomly and the profits according to the three distributions (uncorrelated, weakly correlated and strongly correlated respectively). Then the v items are normalized by setting p k =[2p k /m] andw k =[2w k /m]. The n items are constructed by repeatedly multiplying a random number in the interval w j

7 Solving the Hard Knapsack Problems 161 Table 1. Average execution times (ms) for instances with large coefficients, Expknap uncorr. weakcorr. str.corr. inv.str.corr. al.str.corr. sub.sum n\r Table 2. Average execution times (ms) for instances with large coefficients, Minknap uncorr. weakcorr. str.corr. inv.str.corr. al.str.corr. sub.sum n\r Table 3. Average execution times (ms) for instances with large coefficients, BPSO uncorr. weakcorr. str.corr. inv.str.corr. al.str.corr. sub.sum n\r Table 4. Optimal values found by GA and our BPSO, R =10 6, c = 1 n 2 j=1 wj for all the instances uncorr. str.corr. n GA BPSO GA BPSO [1,m] and any item from the spanner set. Here, we will consider uncorrelated span(2,10), weakly correlated span(2,10) and strongly correlated span(2,10). Multiply strongly correlated instances mstr(k 1,k 2,d): The weights are chosen in [1,R] randomly. If the weight can divide exactly by d, then the profit p j =w j +k 1, otherwise p j =w j +k 2. The parameters are k 1 =3R/10, k 2 =2R/10, d=6.

8 162 B. Ye, J. Sun, and W.-B. Xu Table 5. Average execution times (ms) for instances with small coefficients, Expknap span(2, 10) mstr( 3R n uncorr. weak. corr. str. corr. circle( 2 ) Table 6. Average execution times (ms) for instances with small coefficients, Minknap span(2, 10) mstr( 3R n uncorr. weak. corr. str. corr. circle( 2 ) Table 7. Average execution times (ms) for instances with small coefficients, BPSO span(2, 10) mstr( 3R n uncorr. weak. corr. str. corr. circle( 2 ) Table 8. Optimal values found by GA and BPSO, for three types of difficult instances, R=1000 str.corr.span(2, 10) mstr( 3R, 6) pceil(3) n GA BPSO GA BPSO GA BPSO Profit ceiling instances(d): The weights are randomly distributed in [1,R] and profits p j =d w j /d. The parameter d is chosen as d=3. Circle instances(d): The weights are randomly distributed in [1,R] and p = d 4R 2 (w 2R) 2.Wechoosed = 2 3. From these results, it is clear that Expknap has the worst performance than any other algorithms. Although Minknap is a bit faster than our algorithm for

9 Solving the Hard Knapsack Problems 163 smaller problem size n, the solution times for both algorithm are very stable. Here again, Table 8 shows that our BPSO algorithm performs better than GA. 5 Conclusion In this paper, we proposed a novel binary particle swarm approach and apply it to the hard knapsack problems. Based on the total-value greedy algorithm, a heuristic operator is designed to handle the knapsack constrains. The approach has been thoroughly evaluated with different instance types and problem sizes. The evaluation is made by comparing our algorithm with some of the best known approaches in the existing literatures. As the obtained results show, our approach exhibits an excellent level of accuracy and efficiency to the hard knapsack problems. References 1. Pisinger, D.: A Minimal Algorithm for the 0-1 Knapsack Problem. Operations Research, 45 (1997) Martello, S., Pisinger, D., Toth, P.: Dynamic Programming and Strong Bounds for the 0-1 Knapsack Problem. Management Science, 45 (1999) Martello, S., Toth, P.: A New Algorithm for the 0-1 Knapsack Problem. Management Science, 34 (1988) Pisinger D.: An Expanding-Core Algorithm for the Exact 0-1 Knapsack Problem. European Journal of Operational Research, 87 (1995) Gandibleux, X., Freville, A.: Tabu Search Based Procedure for Solving the 0-1 Multiobjective Knapsack Problem: The two Objectives Case. Journal of Heuristics, 6 (2000) Chu, P.C., Beasley, J. E.: A Genetic Algorithm for the Multidimensional Knapsack Problem. Journal of Heuristics, 4 (1998) Thiel, J., Voss, S.: Some Experiences on Solving Multiconstraint Zero-One Knapsack Problems with Genetic Algorithms. INFOR, Canada, 32 (1994) Pisinger, D.: Where are the Hard Knapsack Problems? Computers & Operations Research, 32 (2005) Kennedy, J., Eberhart, R. C.: Particle Swarm Optimization. IEEE int. Conf. on Neural Networks, Perth Australia, 325 (1995) Parsopoulos, K. E., Vrahatis, M. N.: Recent Approaches to Global Optimization Problems through Particle Swarm Optimization. Natural Computing: An International Journal, 1 (2002) Kennedy, J., Eberhart, R. C.: A Discrete Binary Version of the Particle Swarm Algorithm. In Proceedings of the World Multiconference on Systemics, Cybernetics and Informatics, IEEE Press, (1997) Pampara, G., Franken, N.,Engelbrecht, A. P.: Combining Particle Swarm Optimization with Angle Modulation to Solve Binary Problems. IEEE Congress on Evolutionary Computation, 1 (2005) Van Den Bergh, F.: An Analysis of Particle Swarm Optimizers. PhD thesis, Department of Computer Science, University of Pretoria, South Africa (2002) 14. Kohli, R., Krishnamurti, R., Mirchandani. P.: Average Performance of Greedy Heuristics for the Integer Knapsack Problem. European Journal of Operational Research 154 (2004) 36 45