Available online at www.sciencedirect.com
European Journal of Operational Research 192 (2009) 767–781 www.elsevier.com/locate/ejor
Discrete Optimization
An agent-based approach to the two-dimensional guillotine bin packing problem Sergey Polyakovsky a, Rym M’Hallah b
b,*
a Department of Computer Science and Robotics, Ufa State Aviation Technical University, Ufa, Russia Department of Statistics and Operations Research, Kuwait University, P.O. Box 5969, Safat 13060, Kuwait
Received 21 September 2006; accepted 11 October 2007 Available online 18 October 2007
Abstract The two-dimensional guillotine bin packing problem consists of packing, without overlap, small rectangular items into the smallest number of large rectangular bins where items are obtained via guillotine cuts. This problem is solved using a new guillotine bottom left (GBL) constructive heuristic and its agent-based (A–B) implementation. GBL, which is sequential, successively packs items into a bin and creates a new bin every time it can no longer fit any unpacked item into the current one. A–B, which is pseudo-parallel, uses the simplest system of artificial life. This system consists of active agents dynamically interacting in real time to jointly fill the bins while each agent is driven by its own parameters, decision process, and fitness assessment. A–B is particularly fast and yields near-optimal solutions. Its modularity makes it easily adaptable to knapsack related problems. 2007 Elsevier B.V. All rights reserved. Keywords: Heuristics; Cutting and packing; Two-dimensional bin packing; Agent-based systems; Artificial intelligence
1. Introduction Several real life industrial applications require the allocation of a set of small objects (or items or pieces) into the smallest number of large objects (or stock units or bins). For instance, in glass, plastic or metal industries, rectangular components have to be cut from the fewest large sheets of material. Similarly, when filling the pages of a newspaper, the editor has to arrange articles and advertisements, presented as rectangular areas, on pages of fixed dimensions. In the shipping and transportation industries, packages of identical heights have to be positioned in the minimum number of rectangular bins. This frequently occurring cutting and packing problem is known in the literature as the two-dimensional single bin-size bin packing (2BP) problem [27]. Formally, it consists of allocating, without overlap, a set N = {1, . . . , n} of *
Corresponding author. Tel.: +965 6914150. E-mail addresses:
[email protected] (S. Polyakovsky), mhallah@ kuc01.kuniv.edu.kw (R. M’Hallah). 0377-2217/$ - see front matter 2007 Elsevier B.V. All rights reserved. doi:10.1016/j.ejor.2007.10.020
small rectangular items into the minimum number of identical large rectangular bins. An item i 2 N is characterized by its length li and width wi, and a bin is characterized by its length L and width W. Variants of the 2BP arise when additional constraints are imposed. Generally, the constraints reflect conditions of the arrangement of items into the bins and/or technological constraints [25] such as limiting the number of cuts, requiring guillotine cuts because of the use of automated cutting machines [15], imposing an orientation on the items, etc. This paper focuses on two-variants of the guillotine 2BP. • The first variant imposes a fixed orientation of the items; i.e., a piece of length l and width w is different from a piece of length w and width l (when l 5 w). It is denoted 2BPjOjG, where O refers to oriented items and G to the requirement that the cuts be guillotine. It is of particular interest in rubber cutting [24,15], newspaper paging, and in apparel industries in particular when items are cut from decorated or patterned material.
768
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
• The second variant allows the items to be rotated by 90; i.e., a piece of length l and width w may be positioned either with its length or with its side along the length L of the bin. It is denoted 2BPjRjG where R refers to the feasibility of rotation of the items by 90 and G to the requirement that the cuts be guillotine. It is applicable in the steel and shipping industries [26,15]. The 2BPjwjG (where w = O or R) is a difficult combinatorial optimization problem. In fact, the 2BP problem is NP-hard in the strong sense since it is an extension of the well-known one-dimensional bin packing (1BP) problem. Therefore, solving 2BPjwjG using exact approaches is generally impossible; especially when instances involve a large number of items. Indeed, the search for any exact solution is time consuming without any guarantee of a sufficiently good convergence to optimum [25]. One alternative is to search for an approximate local extremum by sorting the items and packing them in the bins according to some prescribed order [25]. This paper uses this line of approach to solve the 2BPjwjG problem. Specifically, it proposes two approximate algorithms: a new guillotine bottom left (GBL) constructive heuristic, and its agent-based (A–B) implementation. GBL positions items in the bottom left (or south-west) most available position of the bin, and decides whether the first cut of the strip containing the packed item is horizontal or vertical. It subsequently updates the two unused areas of the bin, and continues the filling process until no unpacked item fits in the bin. It creates a new bin every time the current one is saturated. It repeats this process until it packs all items. A–B, which is based upon distributed artificial intelligence, has a more global vision of the packing process since it allows the items and the bins to communicate. It uses a dynamic pseudo-parallel agent-based system of active interacting agents; each with its own characteristics (parameters), fitness, and decision process (or rules or logic of work) whose basis is GBL. It uses the principle of selforganization of the agents to construct a feasible solution p. It then intensifies the search in the immediate neighborhood of p exploiting the information it learned. It maintains the ‘‘good’’ parts of p and rebuilds the ‘‘weaker’’ ones. Finally, it diversifies the search by using different orderings of the items. A–B mimics agent-based economic systems [21]. Its agents’ interaction forms a model of the environment and assesses the potential of each activity. Agents use this information to simulate variants of their activity, and subsequently readjust their activity, their decision process, and their characteristics. Results of agents’ activity are disseminated in the system, and fed back to the agents [21]. The process is reiterated until the system reaches steady state. Subsequently, the process launches group breaking actions in a greedy manner in search for a local optimum. This paper is organized as follows. Section 2 surveys methods used to solve the 2BP problem. Section 3 details
the constructive approach GBL and the approximate algorithm A–B. Section 4 evokes issues related to A–B’s implementation, and assesses GBL’s and A–B’s performance in terms of run time and solution quality. Finally, Section 5 summarizes the paper highlighting A–B’s advantages, and discussing its application to other combinatorial optimization problems.
2. Literature review The 2BP problem has been widely studied [20,18]. Lodi et al. [16,17] provide a survey of recent advances on the subject; summarizing available bounds, and common exact and approximate approaches. One of the novel exact methods is proposed by Dell Amico et al. [7] who introduce a lower bound to the 2BP problem with rotation, and embed it into an exact branch-and-bound. Most approximate algorithms [2,4,13–15] use a twophase approach [2]. The first phase packs all items into a strip of fixed length but infinite width whereas the second phase subdivides the strip into strips of finite length and packs them into the bins. Berkey and Wang [2] propose a finite best fit strip (FBS) and a finite first fit (FFF) algorithm for the 2BPjOjG. FBS packs items according to a best fit decreasing policy where the item is packed in the current strip if it fits in it, and in a new strip otherwise. It packs the resulting strips into the bin whose residual width is minimal or into a new bin if a strip does not fit into any of the already existing bins. FFF, of time complexity O(n2), packs the current item into the lowest strip or into a new strip of the first bin which can accommodate it, or in the bottom left most position of a new bin. Lodi et al. [13] adapt FBS and FFF to the 2BPjRjG, and present a floor ceiling (FC) approach. They classify items as horizontal (resp. vertical) when their longest (resp. shortest) side is set horizontally. They position an item horizontally when a new strip or a new bin is created, and favor positioning it vertically in an existing strip if such a packing is feasible. When using FC, they sort pieces in a non-increasing order of their shortest edge. They consider in addition to the bottom left most available position, the right most, and right upper most positions of the strip. They modify the packing to account for the guillotine constraint, and solve the second phase using an exact algorithm for 1BP. They prove that FC outperforms FBS and FFF. Some approximate algorithms are based on adaptation of metaheuristics. For instance, Lodi et al. [15] introduce a tabu search algorithm that undertakes a search that is independent of the packing problem and whose neighborhood’s size and structure are dynamic. The search recombines, through a constructive heuristic, a subset of items currently packed into a subset of the bins, plus one item currently packed in a target bin which is to be emptied. The constructive heuristic for the 2BPjOjG is a two-phase
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
algorithm with the strip packing phase requiring the resolution of a series of knapsack problems, and the bin packing phase requiring the resolution of the 1BP problem. Lodi et al. [15] adapt the constructive heuristic for the 2BPjOjG to the 2BPjRjG by introducing the concept of a pseudo-item and favoring the vertical orientation of the item whenever possible. Faero et al. [9] extend Dowsland’s [8] approach to the 2BP. They use a guided local search where a neighborhood is explored through item swaps. When the current solution is not optimal, the algorithm randomly assigns the items packed in the highest numbered bin to the other bins. When the new solution is not feasible, a new objective function reflecting the total pairwise overlap and a penalty due to infeasible patterns is minimized. The search is stopped when the incumbent is proven optimal or a pre-fixed time limit is reached. Newer approximate approaches have been designed for other variants of the 2BP. For instance, Binkley and Hagiwara [3] portray for the non-guillotine 2BP a four corner heuristic that is used in conjunction with a self-adaptive parallel simulated annealing algorithm and a self-adaptive genetic algorithm. Puchinger and Raidl [23] consider a typical problem in glass manufacturing: the three-stage 2BP where the number of guillotine cuts cannot exceed 3. They design two polynomial-sized integer linear models, and a branch-and-price algorithm based on a set covering formulation for 2BP. Finally, Correa [5,6] construct a polynomial time algorithm for packing two-dimensional rectangles into the minimum number of unit squares, when 90 rotations are allowed, and get near-optimal packing results for a number of related packing problems. Most of the aforementioned approaches are traditional: they are oriented toward solving a particular problem rather than a general class of problems. Despite the efficiency of some of these approaches, their adaptation to related problems is complex; generally requiring a totally new design of the approach. This paper overcomes this shortcoming by solving the 2BPjwjG problem using a new distributed artificial intelligence framework that can be easily adapted to other types of cutting and packing problems. 3. An agent-based approach A–B, an approach based upon distributed artificial intelligence, solves the 2BPjwjG problem using a new sequential packing heuristic GBL as part of its decision process. Section 3.1 details GBL, whereas Section 3.2 describes A–B. 3.1. GBL GBL is a constructive algorithm for the guillotine twodimensional bin packing. Its application to the 2BPjOjG, 2BPjRjG, and related problems follows.
769
3.1.1. GBL for 2BPjOjG GBL proceeds by allocating every large item to a large bin, and filling the remaining unused area of every bin using small items. For 2BPjOjG, an item i 2 N is large if i 2 I = {i 2 N : li > L/2, wi > W/2}, and small if i 2 I ¼ N n I. Indeed, no pair of large items (i 0 , i00 ) 2 I · I can fit within a single bin. Specifically, GBL considers bin j = 1, and initializes a priority list U to I [ I, where both I and I are sorted in a non-ascending order of the areas of their items. It initializes S 0 the unused area of bin j to the whole bin by setting the dimensions (L 0 , W 0 ) of S 0 to (L, W). Moreover, it sets the bottom left position of S 0 to (x 0 , y 0 ) = (0, 0). Furthermore, it initializes the set Jj of items contained in bin j to the empty set; i.e., Jj = ;. Then, it chooses the first item i 0 2 U, includes it in Jj, and removes it from U. Subsequently, it calls the recursive self-calling routine GBLr[(L 0 , W 0 ), (x 0 , y 0 ), (l 0 , w 0 )] (where r stands for recursive routine). This routine, described in Table 1, starts by packing item i 0 = (l 0 , w 0 ) into S 0 which is characterized by its dimensions (L 0 , W 0 ) and coordinates (x 0 , y 0 ). Piece i 0 to be packed in S 0 can be obtained via a horizontal or a vertical cut. • When piece i 0 is obtained via a horizontal cut, S 0 is split – as shown in Fig. 1a – into two horizontal strips: a strip S1 = (L 0 , W 0 w 0 ) above i 0 , and a strip composed of i 0 and of the unused area S 1 ¼ ðL0 l0 ; w0 Þ to its right. • On the other hand, when piece i 0 is obtained via a vertical cut, S 0 is split – as shown in Fig. 1b – into two vertical strips: a strip S2 = (L 0 l 0 , W 0 ) to the right of i 0 , and a strip composed of i 0 and of the unused area S 2 ¼ ðl0 ; W 0 w0 Þ on top of i 0 . The self-recursive routine GBLr chooses the type of cut to be adopted by comparing the areas of S1 and S2. It favors the cut that yields the unused strip with the largest area: the larger the area, the higher the chances of the bin to end up with a packing coefficient close to 1. (The packing coefficient of the bin is the ratio of the sum of the areas of the items assigned to the bin to its area. It cannot exceed 1.) When the area of S1 is larger than the area of S2, GBLr fills S1 then S 1 : • To fill S1 = (L 0 , W 0 w 0 ), GBLr determines the set U 0 of items that fit into S1, where U 0 = {i 2 U : li 6 L 0 , wi 6 W 0 w 0 }. If U 0 5 ;, GBLr identifies the item i00 2 U 0 whose area is largest, removes it from U, appends it to Jj, and calls GBLr[(L 0 , W 0 w 0 ), (x 0 , y 0 + w 0 ), (l00 , w00 )] to pack i00 in (x 0 , y 0 + w 0 ), the bottom left most position of S1. • To fill S 1 ¼ ðL0 l0 ; w0 Þ, GBLr determines the set U 0 of items that fit into S 1 , where U 0 = {i 2 U : li 6 L 0 l 0 , wi 6 w 0 }. If U 0 5 ;, GBLr identifies the item i00 2 U 0 whose area is largest, removes it from U, appends it to Jj, and calls GBLr[(L 0 l 0 , w 0 ), (x 0 + l 0 , y 0 ), (l00 , w00 )] to pack i00 in (x 0 + l 0 , y 0 ), the bottom left most position of S 1 .
770
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
Table 1 The recursive self-calling routine GBLr[(L 0 , W 0 ),(x 0 , y 0 ), (l 0 , w 0 )]
• To fill S2 = (L 0 l 0 , W 0 ), GBLr determines the set U 0 of items that fit into S2, where U 0 = {i 2 U : li 6 L 0 l 0 , wi 6 W 0 }. If U 0 5 ;, GBLr identifies the item i00 2 U 0 whose area is largest, removes it from U, appends it to Jj, and calls GBLr[(L 0 l 0 , W 0 ), (x 0 + l 0 , y 0 ), (l00 , w00 )] to pack i00 in (x + l 0 , ,y 0 ), the bottom left most position of S2. • To fill S 2 ¼ ðl0 ; W w0 Þ, GBLr determines the set U 0 of items that fit into S 2 , where U 0 = {i 2 U : li 6 l 0 , wi 6 W w 0 }. If U 0 5 ;, GBLr identifies the item i00 2 U 0 whose area is largest. It appends it to Jj, and calls GBLr[(l 0 , W w 0 ), (x 0 , y 0 + w 0 ), (l00 , w00 )] to pack i00 in (x 0 , y 0 + w 0 ), the bottom left most position of S 2 . When GBLr stops and U 5 ;, the current bin j can no longer fit any of the remaining unpacked items. Subsequently, the heuristic creates a new bin: it increments j by 1 and sets (L 0 , W 0 ) = (L, W) and (x 0 , y 0 ) = (0, 0). It then starts filling the new bin: it chooses i 0 , the first item of U, packs it into bin j setting Jj = {i 0 }, removes it from U, and calls procedure GBLr[(L 0 , W 0 ), (x 0 , y 0 ), (l 0 , w 0 )]. This iterative step is repeated until all items are packed; that is, until U = ;. 3.1.2. GBL for 2BPjRjG Adapting GBL to 2BPjRjG is straightforward. It simply involves altering the definitions of I and U 0 . In fact, the set of large items becomes I = {i 2 N : max{li, wi} > max{L/ 2, W/2}, min{li, wi} > min{L/2, W/2}}. The set of items that fit into the unused area S 0 = (L 0 , W 0 ) of a bin becomes U 0 = {i 2 U : max{li, wi} 6 max{L 0 , W 0 }, min{li, wi} 6 min {L 0 , W 0 }}. Item i 2 U 0 is rotated if li > L 0 or wi > W 0 .
On the other hand, when the area of S2 is larger than that of S1, GBLr fills S2 then S 2 :
3.1.3. Applications of GBL GBL can be easily adapted to two important industrial problems: on-line bin packing, and non-identical bins. Adapting GBL to on-line bin packing requires adjusting U as new demand occurs; i.e., the new items are inserted into the current U while the steps of the algorithm are executed. Adapting GBL to the non-identical bins case is straightforward. It involves altering the definitions of I and S 0 , and considering the bins in the non-increasing order of their areas. For instance, for the 2BPjOjG problem, the definition of the set of large items becomes I = {i 2 N : li > minj{Lj/2}, wi > minj{Wj/2}}, where Lj
Fig. 1. Illustrating the unused areas resulting from a horizontal and a vertical cut.
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
and Wj are the length and width of bin j. For the 2BPjRjG problem, the definition of the set of large items becomes I = {i 2 N : max{li, wi} > maxj{Lj/2, Wj/2}, min{li, wi} > minj{Lj/2, Wj/2}}. Initially, S 0 the unused area of bin j is set to the whole bin: S 0 = (L 0 , W 0 ) = (Lj, Wj). 3.2. An agent-based approach The proposed A–B assimilates the items of the bin packing problem to agents that interact simultaneously (not sequentially). It adopts a pseudo-parallel working environment where agents work in parallel in real time [21]. It is described in this section using the agents’ interaction specification protocols [11] and communication diagrams of the Foundation for Intelligent Physical Agents (FIPA). The diagrams are read from top to bottom with the arrows corresponding to communication channels between the agents. The rectangles are states or internal procedures which help agents undertake their own decisions. The dotted lines express time intervals. A bifurcation of the arrow indicates that the agent can send two types of information depending on its decision process. The response of the receiving agent depends on the type of information it receives. In the A–B system, agents, whose interaction is dynamic, proclaim themselves agent-initiators or individual-agents. • An agent-initiator creates a group and competes to attract the best individual-agents toward its group. Its goal is to maximize its group’s fitness measured via its packing coefficient. Differently stated, its goal is to fill a bin as efficiently as possible by inviting individualagents to join its group and packing them into the bin while respecting both the guillotine and the capacity constraints dictated by L and W. • An individual-agent is either free (if it does not belong to any agent-initiator’s group) or busy. A free individualagent i competes to join the agent-initiator that maximizes i’s purpose parameter – measured via i’s occupancy ratio. The occupancy ratio rij of free individual-agent i in the available area Sj of agent-initiator j is the ratio of the area of i to the area of Sj. Evidently, i considers joining the group of j only if rij 6 1 (since i does not fit into Sj if rij > 1), and prefers joining a group that will make its occupancy ratio equal 1. The interaction of the agent-initiators and individualagents within the system mimics the behavior of a group of college graduates seeking employment in a free market (system). A subset of these graduates may decide to create firms, and proclaim themselves managers (agent-initiators). The remaining graduates (individual-agents) will be seeking to join one of the created firms. Evidently, each firm’s manager tries to attract the most competent graduates, and every graduate will opt to join the firm that best fits his/ her own objectives (be them career advancement or salary or working hours, etc.). Since the market is dynamic, graduates can move from one firm to another and/or create
771
their own firms. Similarly, firms may merge, expand, break up into two or more firms, hire additional individualagents, fire some of them, etc. A–B, which is detailed in Table 2, proceeds as follows. First, it creates n free individual-agents corresponding to the n items of N, and initializes the set A of agent-initiators to the empty set. It then feeds the system with • a priority list U of free individual-agents (e.g., U ¼ I [ I with I and I ordered in non-ascending order of their areas), and • the number M 6 n of agents that initially declare themselves agent-initiators. It uses M to initialize the number m of agent-initiators simultaneously existing and interacting in the system; i.e., initially m = M, and at any given point in time, 1 6 m 6 n. A–B chooses the m agent-initiators as the first m items of U. It removes them from U, and enters them into A. An individual-agent j initializing itself an agent-initiator creates its own group. It positions itself in the bottom left most position of the bin; that is, in position (xj, yj) = (0, 0). It initializes its group set Jj = {j}; and chooses the cut type by favoring the one that yields the largest area. Subsequently, it enters into its queue of vacancies, Cj, the two unused areas fS 1 ; S 1 g if the cut is horizontal or fS 2 ; S 2 g if the cut is vertical. Each element of Cj is characterized by its attributes which are its dimensions and relative coordinates with respect to its bin. Cj is a first-in-first-out queue; so the first element of Cj is processed first while all newly created elements (areas) are tagged to the end of the queue. Having been initialized, agent-initiator j undertakes group formation actions which are directed toward inviting a subset of the free individual-agents (i.e., items of U) to join the group. j sets its current unused area Sj to the first vacancy queued in Cj. It then identifies the best free individual-agents that can be positioned in Sj (cf. state 1 of Fig. 2), and invites each of them to join its group by sending it an attachment offer. The attachment of any of these free individual-agents to group j increases the packing coefficient of the bin; thus, improves the fitness of j. When receiving an offer from an agent-initiator j 2 A, a free individual-agent i 2 U processes it and decides whether to reject it or accept it (cf. respectively states 2 and 3 of Fig. 2). To reach its decision, i analyzes the offer and considers all possible potential offers that may emanate from other agent-initiators. To determine these alternatives, i undertakes a group joining action, as illustrated by Fig. 3. (This action reflects the individual objective of each free agent: each is seeking to join a group where its occupancy ratio will be as close to 1 as possible.) i sends each potential agent-initiator j 0 2 An{j} a request of subscription which asks for information regarding the vacancies of C j0 that can fit it (cf. state 13 of Fig. 3). Upon receipt of the request from i, an agent-initiator j 0 2 An{j} processes the request by sending the suitable elements of its C j0 back to i
772
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
Table 2 The A–B system
(cf. states 14 and 15 of Fig. 3). i analyzes these vacancies and compares them to Sj (cf. state 16 of Fig. 3): It computes its occupancy ratio for each vacancy, and reaches a
decision. If rij is close to 1 and is the highest ratio among all potential agent-initiators’ vacancies, i accepts the invitation of agent-initiator j; else, it rejects it. Upon undertaking
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
773
• The free individual-agents that j invited but did not finally choose do not change their state: each of them remains free (cf. state 11 or 12 of Fig. 2), and pursues its endeavor of group joining. • The free individual-agent i* that j invited and chose receives – along with the confirmation notification (cf. state 11 or 12 of Fig. 2) – its orientation and position coordinates as decided by j. i* changes its state from free to busy, leaves U, and updates its attributes, which are its orientation and coordinates. • Subsequently, agent-initiator j attaches i* to its group: Jj = Jj [ {i*}. It chooses the type of cut by comparing the areas of S 1 ¼ ðLj ; W j wi Þ and S 2 ¼ ðLj li ; W j Þ, and updates Cj by removing Sj and tagging the two newly created unused areas to the end of Cj.
Fig. 2. Description of a group formation action.
*States 13 and 16 are a partial decomposition of states 2 and 3 of Figure 2. Fig. 3. Description of a group joining action.
a decision, i informs j of its decision regarding the group formation request it received (cf. states 8 and 9 of Fig. 2). Agent-initiator j records the response of each of the free individual-agents it invited; be it a refusal (states 4 and 6 of Fig. 2) or a confirmation (states 5 and 7 of Fig. 2). It then analyzes these responses, chooses the most eligible free individual-agent i* (cf. state 10 of Fig. 2), and notifies all the free individual-agents it invited about its decision.
If no free individual-agent is attached to j, Sj = (Lj, Wj) is removed from Cj. Sj is permanently removed from the agent-initiator’s memory if none of the n items fits Sj; that is, Lj < mini=1,n{li}, or Wj < mini=1,n{wi}. On the other hand, if there are items that fit into Sj but are currently busy individual-agents or agent-initiators, then Sj is appended into the queue of non-filled vacancies C j . By joining C j ; S j will later be reconsidered for possible filling when group breaking actions take place. The process described above is reiterated until none of the m agent-initiators can extend an invitation. In such a case, if there are free individual-agents in the system, then the first m individual-agents of U initialize themselves agent-initiators (in addition to the existing agent-initiators), append themselves to A, and build their own groups. On the other hand, if there is no free individual-agent in the system, the current solution is feasible. When a feasible solution p is at hand, the system investigates the neighborhood of p in search for a local optima. It classifies the components of p as ‘‘weak’’ and ‘‘strong’’, where the weak (resp. strong) components correspond to the groups of agent-initiators having a low (resp. high) fitness. The fitness of the group of Pthe agent-initiator j is low if its packing coefficient aj ¼ ð i2J j li wi Þ=ðLW Þ is less than or equal to a threshold packing coefficient a 2 [0, 1]. The system maintains p’s strong components, and rebuilds the weak ones. Indeed, it maintains intact the groups characterized by a high fitness, whereas it frees all agents belonging to low fitness groups and makes them undertake group joining and forming actions. Differently stated, the system undertakes group breaking actions followed by group joining and forming actions. In a socio-economic context, group breaking actions are equivalent to the death of a firm due to competition. Subsequently, the firm’s employees – including the manager of the firm – undertake either group joining actions, oriented toward joining one of the existing firms, or group forming actions, oriented toward creating new firms. Specifically, when a feasible solution p is obtained, the system decreases m by one and initiates a reconstruction process via group breaking actions. The busy agents of a
774
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
Fig. 4. Description of a group breaking action.
group j ask agent-initiator j if a group breaking activity is to be undertaken (cf. states 17 and 18 of Fig. 4). To decide whether its group should be disassembled or kept intact (cf. state 19 of Fig. 4), agent-initiator j compares its aj to a. j decides to keep Jj grouped if aj > a, and to disassemble otherwise. Upon reaching a decision to disassemble, agent-initiator j relays this decision to the elements of Jj. The elements of a disassembling group change their state from busy to free (cf. states 20 and 21 of Fig. 4). Furthermore, the agent-initiator of a disassembling group changes its nature from an agent-initiator to a free individual-agent; thus leaves A. The freed agents reenter the system by appending themselves to U. They do not regain their initial relative positions in U, but take random positions. They, then, initiate group joining and group forming actions. Meanwhile, surviving agent-initiators seize this opportunity to increase their fitness. Each surviving agent-initiator j invites the freed agents to join its group Jj using any element of C j . The system reiterates the reconstruction process until m = 1; i.e., the system undertakes m 1 group breaking actions yielding m 1 feasible neighbors. The system chooses the best of the m feasible solutions (p and the m 1 neighbors) as a local optimum. A–B (i.e., the algorithm described in Table 2) is subsequently executed a pre-fixed number of independent runs to diversify the search. The best solution is then retained as a global optimum. 4. Computational results This section discusses some implementation issues of A– B, and studies GBL’s and A–B’s performance. Both GBL and A–B are coded in Borland Delphi 6.0 with Object Pascal and run on an Athlon XP 2800. 4.1. Implementation issues A–B’s performance depends on two parameters: M the initial number of agent-initiators, and the threshold level a. When M is set to 1, A–B fills the bins successively; mimicking GBL in that it starts filling a single bin and considers
a new bin every time it fails to pack any additional item into the current one. Thus, A–B behaves as a sequential heuristic rather than as a pseudo-parallel one. On the other hand, when M = n, the solution construction process starts with each bin containing exactly one item, which is the agent-initiator of that bin. Thus, the packing coefficient of every bin is initially small, and convergence to a local optima (by breaking bins and allocating their content to other existing bins) is slow. Similarly, when the threshold level a, used in group breaking actions, is set to 0, no group is disassembled. Thus, the current feasible solution cannot be improved, and the algorithm is prohibited from exploration or evolution. On the other hand, when a = 1, every group is disassembled, and no information is inherited by the new solution from the current one. That is, the algorithm is prevented from exploitation or learning. A good balance between exploration and exploitation, the two competing goals of any good heuristic, is necessary. Exploration allows an extensive search of the solution space in order to determine the part of the space that has a higher chance of containing the global optimum whereas exploitation refines the search and focuses on the part of the space that has a high potential of containing the global optimum. For illustration purposes, consider the instance ngcutfs1_191, considered in [1]. The instance, which has n = 1000 items, has a lower bound LB = 241 [10]. Table 3 summarizes the best solution obtained by A–B for different combinations of M and a for the 2BPjOjG. For this instance, setting M = n is not desirable since it does not yield the best solution. Furthermore, for a given level of (M, a), A–B can yield different solutions (though they are in general in the same neighborhood). Consider another instance consisting of the accumulation of the nine instances ngcutfsd_x, d = 1, 2, 3, and x = 191, 192, 193. The instance, which has 9000 items, has a lower bound LB = 1734 [10]. GBL yields a solution value equal to 1785 whereas A–B yields 1748. For each level of (M, a), this instance is run 10 times using A–B. The average solution value obtained by A–B over the 10 independent runs is then recorded for each pair (M, a). Figs. 5 and 6 display, respectively, the variation of the obtained A–B’s average solution values as a increases for different values of M, and as M increases for different values of a. They reveal that the best results, for this instance, are obtained with
Table 3 Effect of M and a on A–B’s solution quality for ngcutfs_1 M
a
A–B
10 10 10 100 100 1000 1000
0.60 0.90 0.95 0.60 0.95 0.60 0.95
256, 255, 253 256 256, 252 259 256, 252 276 259
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781 Solution Value
775
Run Time (seconds)
1800
800
M=1
1790
M=3
1780
M=10
600
M=40 1770
M=1
M=100
M=3 1760
400
M=10 M=40
1750
200
M=100 1740 0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
α
0
Fig. 5. Average solution quality for a 9000-item instance as a varies.
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
α
Fig. 7. Average run time for a 9000-item instance as a varies. Solution Value 1800
Run Time (seconds) 800
α=0.6 α=0.8
1790
α=0.90 α=0.95
1780
α=0.6 α=0.8 α=0.90 α=0.95 α=0.97 α=0.99
600
α=0.97 α=0.99
1770
400
1760 200 1750 0 M
1740 0
50
100
150
200
250
300
0
50
100
150
200
250
300
M
Fig. 8. Average run time for a 9000-item instance as M varies.
Fig. 6. Average solution quality for a 9000-item instance as M varies.
a = 0.95 for all values of M except for M = 10 where the best result is obtained with a = 0.97. Fig. 5 shows that preventing exploitation of the search space by setting a too close to 1 (e.g., a = 0.99) may hinder A–B’s performance (as it the case for this instance). Similarly, too much exploitation is counterproductive as lower a levels tend to deteriorate the solution quality. It is recommended, for this instance, to set a at a relatively ‘‘high’’ level within the neighborhood of 0.95. This recommendation maintains a reasonable average run time (in particular for M 6 100), as illustrated by Figs. 7 and 8. In general, it is advised not to increase a beyond 0.97 as the run time may increase significantly. Fig. 5 further indicates that increasing M does not necessarily improve A–B’s average solution value. Indeed, except for a = 0.95, all average solutions for M = 10 are better than their counterparts with M = 100. This is further confirmed by Fig. 6. Therefore, for this instance, setting M at a ‘‘low’’ level is preferable especially that increasing M increases the average run time, as illustrated by Fig. 8, without any guarantee of solution improvement. In general, it is better to choose the most appropriate level of the pair (M, a) rather than setting their levels separately. Even though the ‘‘best’’ levels are instance
dependent, the following guidelines offer A–B enough opportunities for exploration and exploitation; and most importantly, provide it with a good tradeoff between these two competing goals. Based on the observed behavior of the algorithm on all tested instances, it is recommended that M be set at three different levels: M = 3, 10, and min{40, n} for instances whose n < 100, and M = 10, 40, and 70 for instances whose n P 100. Similarly, it is recommended that a be set at two distinct levels: a level from the set {0.6, 0.7}, and a level from the set {0.9, 0.95}. Each pair can be replicated several times (for example, 10 times), and the pair yielding the best solution is retained. A–B is then rerun with that level of (M, a). These recommendations have been adapted for the computational investigation of Section 4.2. 4.2. Evaluation of GBL and A–B GBL and A–B are assessed in terms of run time, and solution quality (i.e., quality of the packing of a single bin, and minimum number of bins). 4.2.1. Run time In terms of run time, both GBL and A–B are very fast. GBL is a polynomial-time algorithm of complexity O(n2).
776
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
It solves very large problems (up to 100,000 items) in very short computational times. Similarly, A–B’s run time varies on average between 10 milliseconds for n = 40 and 145 seconds for n = 10,000 with M = 10 and a = 0.95. It is less than 14 minutes for n = 100,000 with M = 3 and a = 0.95, and less than 38 minutes with M = 10 and a = 0.95. A–B’s run time can further be reduced using a special data structure as discussed in [22]. For instance, for n = 5000, it can be reduced from 28,210 to 7900 milliseconds and from 144,600 to 63,500 milliseconds for n = 10,000. Table 4 illustrates the variation of GBL’s and A–B’s run time as n varies. The run times are small; thus, will not be further discussed.
4.2.2. Packing quality The quality of the packing GBL and A–B induce is evaluated on the 21 instances of [12]: seven classes with n ranging from 16 to 197 items, and three problems per class. The dimensions of the rectangles have a maximum aspect ratio of 7 while the ratio L/W varies between 1 and 3. The n Table 4 Variation of GBL’s and A–B’s run time (in milliseconds) for M = 10 and a = 95 n
GBL
A–B
50 500 1000 5000 10,000
10 20 120 10,400 96,800
15 90 530 28,210 144,600
items can be packed into the bin with a 100% packing coefficient if the guillotine constraint is not reinforced. Columns 1 and 2 of Table 5 display respectively the instance and the number of items n. Column 3 (resp. 7) reports the packing coefficient of GBL’s solution expressed as a percentage whereas columns 4–6 (resp. 8–10) display the maximum, minimum, and average packing coefficient expressed as a percentage over 500 independent runs of A–B for the 2BPjOjG (resp. 2BPjRjG). (Indeed, for each instance, the algorithm was run 500 times, and the solution for each run was recorded.) Table 5 shows that the guillotine constraint is not very restrictive (except for instance C1_2) since the packing ratio is close to 100%. GBL yields a dense packing. GBL’s average packing coefficient is 91.10% for 2BPjOjG and 93.95% for 2BPjRjG. It reaches 97.68% for 2BPjOjG for instance C7_2 and 97.57% for 2BPjRjG for instance C6_1. GBL’s performance improves as n increases, as depicted in Fig. 9. GBL performs better for 2BPjRjG than for 2BPjOjG: Allowing the rotation of the pieces by 90 adds flexibility to GBL, and makes it converge to a better solution. A–B improves GBL’s packing, on average, by 6.58% for 2BPjOjG and by 5.11% for 2BPjRjG. These improvements reach 21.50% for 2BPjOjG for instance C1_3 and 10.33% for 2BPjRjG for instance C2_1. However, the random nature of A–B makes it obtain solutions that are not necessarily better than those obtained by GBL during some of its replications. However, these cases are rare, and become less frequent as n increases. This is further confirmed by Figs. 10 and 11 which show that the average and maximum
Table 5 Solution quality of GBL and A–B Instance
C1_1 C1_2 C1_3 C2_1 C2_2 C2_3 C3_1 C3_2 C3_3 C4_1 C4_2 C4_3 C5_1 C5_2 C5_3 C6_1 C6_2 C6_3 C7_1 C7_2 C7_3
n
16 17 16 25 25 25 28 29 28 49 49 49 72 73 72 97 97 97 196 197 196
2BPjOjG
2BPjRjG
GBL
A–B Max.
Min.
Mean
88.00 79.50 78.50 86.67 92.67 94.83 92.33 86.11 87.67 94.83 92.58 89.50 92.80 88.56 94.98 95.47 94.93 94.98 95.29 97.68 95.32
100.00 90.25 100.00 98.00 99.00 100.00 97.56 95.00 100.00 96.22 95.75 98.11 97.70 94.80 98.59 98.48 97.17 98.56 98.53 98.66 99.09
79.50 75.25 71.00 81.67 88.00 74.00 77.44 79.78 84.00 80.19 81.89 84.28 82.57 79.73 79.37 92.28 88.05 94.81 94.68 93.29 95.81
92.30 86.50 86.00 95.50 98.33 98.00 81.11 94.22 86.00 95.61 95.61 97.64 96.28 91.13 90.98 96.97 94.25 96.68 97.03 96.39 97.56
GBL
A–B Max.
Min.
Mean
91.50 86.75 92.75 87.67 92.67 95.00 94.67 90.00 91.67 97.00 91.19 97.22 95.67 93.93 94.85 97.57 96.98 94.86 96.07 97.38 97.50
100.00 96.50 100.00 98.00 99.50 100.00 99.17 97.78 100.00 98.33 98.89 99.14 98.83 98.96 99.43 99.14 99.00 99.21 99.29 99.52 99.48
79.50 75.25 71.00 81.33 80.33 74.00 83.00 82.83 79.78 89.50 93.11 96.00 88.35 91.24 89.76 92.28 92.30 96.18 95.94 96.58 98.21
92.30 89.76 89.73 96.13 93.48 97.14 84.20 91.86 93.11 95.56 96.60 96.78 96.90 95.96 95.62 98.07 96.93 98.47 97.03 97.73 98.83
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
outlier instance C1_2. Ignoring instance C1_2 increase the average packing coefficient for the optimal solution to 99.18% for 2BPjRjG and to 98.06% for 2BPjOjG. A–B reaches the proven optimal solution in 4 out 21 instances for either 2BPjRjG or 2BPjOjG. In general, A–B reaches (near) optimal solutions.
Packing Coefficient
100
80
60
40
2BP|R|G 2BP|O|G
20
Instance Size
0 0
50
100
150
200
Fig. 9. GBL’s packing coefficient as n varies.
Packing Coefficient 100
80
60
40
20
777
max min average
0 C1_1C1_2C1_3 C2_1C2_2C2_3C3_1C3_2C3_3C4_1C4_2C4_3C5_1C5_2C5_3C6_1C6_2C6_3C7_1C7_2C7_3
Instance
Fig. 10. Range of A–B’s packing coefficient for different instances for 2BPjOjG.
Packing Coefficient 100
80
60
4.2.3. Minimum number of bins GBL and A–B’s solution quality, in terms of the number of bins, is first evaluated for the 2BPjOjG on the test instances of [1]. Second, it is compared to the tabu search heuristic of [15] for the 2BPjwjG. A–B’s solution is the global optimum of 50 independent runs. The instances extracted from [1] belong to classes of problems obtained by mixing the four types of items described in Table 6 as indicated in Table 7. For each class, seven problem sizes are considered: n = 40, 50, 100, 150, 250, 500 and 1000. For each problem type, 10 instances are investigated. The bin sizes are L = W = 100. Table 8 reports the results for these instances for the 2BPjOjG. Column 1 refers to the instance where d = 1, 2, 3 indicates the class of the instance whereas column 2 refers to n. Columns 3, 6 and 9 report the lower bound LB for the minimum number of bins. Columns 4 and 5, 7 and 8, and 10 and 11 compute the performance GBL A–B ratios QGBL ¼ ZLB and QA–B ¼ ZLB for the class d = 1, 2 and 3, respectively. ZGBL and ZA–B are the minimum number of bins obtained by GBL and A–B, respectively, for the 2BPjOjG. Table 8 shows that as n increases, the performance of both GBL and A–B improves. Similarly, GBL and A–B perform better for the third class than for the second class; and, in turn, for the second class better than for the first class. Moreover, A–B generally improves the solution obtained by GBL; i.e., QGBL P QA–B. For example, QGBL > QA–B in 16, 15 and 17 out of the 21 instances for the first, second and third class for the 2BPjOjG. The tabu-based heuristics of [15] are tested on 10-classes of instances: Classes 1–6 were proposed by Berkey and
40
20
Table 6 Item classification
max min average
0
Instance C1_1C1_2C1_3C2_1C2_2C2_3C3_1C3_2C3_3C4_1C4_2C4_3C5_1C5_2C5_3C6_1C6_2C6_3C7_1C7_2 C7_3
Fig. 11. Range of A–B’s packing coefficient for different instances for 2BPjRjG.
are close for all instances except C3_1 and C3_3 for 2BPjOjG and C3_1 for 2BPjRjG; i.e., the closer the maximum and the average, the less frequent these occurrences are. A–B’s average packing coefficient is 99.06% for 2BPjRjG and 97.69% for 2BPjOjG. The minimum packing coefficient of the best solution is between 96.50% for 2BPjRjG and 90.25% for 2BPjOjG; corresponding to the
Type
Description
li
wi
1 2 3 4
Wide Long Big Small
[1, 50] [75, 100] [50, 100] [1, 50]
[75, 100] [1, 50] [50, 100] [1, 50]
Table 7 Class composition Class
d=1 d=2 d=3
Item type (%) 1
2
3
4
20 15 10
20 15 10
20 15 10
40 55 70
778
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
Table 8 Solution quality of GBL and A–B on 2BPjOjG instances Instance
n
ngcutfsd_11 ngcutfsd_12 ngcutfsd_13 ngcutfsd_41 ngcutfsd_42 ngcutfsd_43 ngcutfsd_71 ngcutfsd_72 ngcutfsd_73 ngcutfsd_101 ngcutfsd_102 ngcutfsd_103 ngcutfsd_131 ngcutfsd_132 ngcutfsd_133 ngcutfsd_161 ngcutfsd_162 ngcutfsd_163 ngcutfsd_191 ngcutfsd_192 ngcutfsd_193
40 40 40 50 50 50 100 100 100 150 150 150 250 250 250 500 500 500 1000 1000 1000
Class d = 1
Class d = 2
LB
QGBL
QA–B
LB
QGBL
QA–B
LB
QGBL
QA–B
10 9 9 13 12 12 23 26 24 36 33 31 58 63 61 121 121 125 241 230 235
1.200 1.222 1.222 1.154 1.167 1.167 1.174 1.115 1.125 1.111 1.121 1.097 1.086 1.143 1.098 1.091 1.083 1.080 1.079 1.070 1.081
1.200 1.111 1.111 1.154 1.083 1.167 1.130 1.115 1.125 1.056 1.091 1.065 1.069 1.095 1.082 1.066 1.058 1.072 1.041 1.035 1.051
10 9 11 9 9 14 22 21 21 31 30 32 53 52 42 99 93 89 205 183 195
1.200 1.333 1.182 1.333 1.222 1.214 1.182 1.095 1.095 1.097 1.100 1.094 1.132 1.077 1.095 1.051 1.065 1.067 1.054 1.044 1.056
1.200 1.222 1.091 1.111 1.222 1.214 1.136 1.048 1.095 1.065 1.067 1.094 1.094 1.058 1.048 1.040 1.043 1.034 1.034 1.027 1.036
7 6 7 10 8 7 15 18 15 21 20 26 39 39 38 77 79 70 153 149 147
1.143 1.333 1.286 1.200 1.125 1.143 1.133 1.111 1.133 1.095 1.150 1.154 1.077 1.103 1.079 1.052 1.051 1.057 1.039 1.034 1.034
1.000 1.167 1.000 1.200 1.125 1.143 1.067 1.111 1.067 1.048 1.100 1.077 1.051 1.051 1.053 1.039 1.038 1.043 1.026 1.027 1.027
1.128
1.094
1.133
1.094
1.121
1.069
Average ratio
Wang [2], and classes 7–10 were given by Martello and Vigo [18]. For classes 1–6, the item sizes li and wi emanate from the same interval and the bins are squares as described by Table 9. Classes 7–10, which use bins of size L = W = 100, reflect a more realistic situation since the items emanate from a mixture of uniform distributions. Indeed, the items are classified into four types [15] as shown in Table 10, and are mixed as indicated in Table 11. (Uniformly distributed dimensions of items do not make problems easy to solve as it is the case for 1BP [15].) For each class, five problem sizes are considered: n = 20, 40, 60, 80 and 100. Ten instances are generated for each problem type. Table 9 Description of the examples of Berkey and Wang [2] Class
li, wi
L=W
1 2 3 4 5 6
[1, 10] [1, 10] [1, 35] [1, 35] [1, 100] [1, 100]
10 30 40 100 100 [1, 300]
Table 10 Classification of the items of the examples of Martello and Vigo [18] Item type 1 2 3 4
li 2
Class d = 3
L; L 3 1 1; L 1 2 L; L 2 1 1; 2 L
wi 1 1; W 2 2 W ;W 31 W ;W 2 1 1; 2 W
Table 11 Description of the items for the examples of Martello and Vigo [18] Class
7 8 9 10
Item type (%) 1
2
3
4
70 10 10 10
10 70 10 10
10 10 70 10
10 10 10 70
Table 12 shows the class type, the problem size n, and the performance ratio Zw/LB with w = O for 2BPjOjG and R for 2BPjRjG. Z H ¼ Z H FFF for columns 3 and 4, ZH ¼ ZH for columns 5 and 6, and Z H ¼ Z H GBL A–B for columns 7 and 8. (FFF is the Finite First Fit algorithm of Berkey and Wang [2].) For columns 9 and 10, Zw is the solution reported in [15]. It is obtained with a tabu search (TS) – which is very effective in all cases [15]. GBL improves the results of FFF for 2BPjRjG. Its average ratio is 1.084 versus 1.113 for FFF. It is consistently better than FFF except for the instances of classes 4 and 6 for n = 60, and 100, and for the instances of class 10 for n = 20. For 2BPjOjG, GBL’s average ratio (1.122) is very close to FFF’s (1.104). GBL performs better than FFF for class 1 and is approximately as good as FFF for classes 5, 8, 9, and 10. For the other classes, neither FFF nor GBL dominates. Even though GBL’s average performance ratios are slightly higher than those of TS (i.e., 1.122 versus 1.079 for 2BPjOjG, and 1.084 versus 1.065 for 2BPjRjG), GBL does achieve a better solution than TS in many instances. A–B either improves GBL’s solutions or matches them. It decreases the average performance ratios from 1.122 for
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
779
Table 12 Instances of Berkey and Wang [2] and Lodi et al. [15] Class
n
FFF 2BPjOjG
2BPjRjG
2BPjOjG
2BPjRjG
2BPjOjG
2BPjRjG
2BPjOjG
2BPjRjG
1
20 40 60 80 100
1.17 1.12 1.10 1.08 1.07
1.09 1.10 1.12 1.10 1.08
1.10 1.11 1.07 1.04 1.04
1.05 1.04 1.03 1.02 1.03
1.03 1.05 1.03 1.01 1.02
1.00 1.01 1.01 1.00 1.01
1.11 1.08 1.05 1.04 1.05
1.03 1.05 1.05 1.07 1.04
1.108
1.098
1.072
1.034
1.028
1.006
1.066
1.048
1.10 1.10 1.15 1.07 1.06
1.00 1.10 1.10 1.07 1.03
1.20 1.10 1.20 1.10 1.08
1.00 1.10 1.10 1.07 1.03
1.00 1.10 1.00 1.00 1.00
1.00 1.00 1.00 1.00 1.00
1.00 1.10 1.15 1.07 1.03
1.00 1.10 1.15 1.03 1.03
1.096
1.060
1.136
1.060
1.020
1.000
1.070
1.062
1.20 1.18 1.14 1.13 1.12
1.20 1.21 1.20 1.20 1.16
1.30 1.20 1.16 1.19 1.12
1.19 1.11 1.12 1.10 1.09
1.14 1.08 1.09 1.06 1.06
1.04 1.06 1.04 1.04 1.05
1.18 1.12 1.07 1.08 1.09
1.09 1.11 1.10 1.07 1.08
1.154
1.194
1.194
1.122
1.086
1.046
1.108
1.090
1.00 1.10 1.20 1.10 1.10
1.00 1.10 1.10 1.10 1.07
1.10 1.10 1.25 1.17 1.09
1.00 1.00 1.15 1.10 1.10
1.00 1.00 1.10 1.10 1.04
1.00 1.00 1.10 1.03 1.00
1.00 1.10 1.20 1.10 1.10
1.00 1.00 1.10 1.03 1.03
1.100
1.074
1.142
1.070
1.048
1.026
1.100
1.032
1.14 1.11 1.11 1.12 1.12
1.08 1.14 1.13 1.13 1.13
1.18 1.13 1.10 1.09 1.11
1.06 1.06 1.05 1.07 1.06
1.11 1.07 1.05 1.06 1.07
1.02 1.03 1.04 1.04 1.05
1.13 1.09 1.07 1.08 1.09
1.04 1.07 1.07 1.08 1.07
1.120
1.122
1.122
1.060
1.072
1.036
1.092
1.066
1.00 1.40 1.10 1.00 1.13
1.00 1.40 1.05 1.00 1.10
1.10 1.40 1.20 1.03 1.20
1.00 1.40 1.10 1.00 1.13
1.00 1.40 1.05 1.00 1.10
1.00 1.30 1.00 1.00 1.07
1.00 1.50 1.10 1.00 1.10
1.00 1.40 1.05 1.00 1.07
1.126
1.110
1.186
1.126
1.110
1.074
1.140
1.104
1.10 1.11 1.08 1.07 1.04
1.19 1.17 1.18 1.19 1.17
1.18 1.14 1.11 1.10 1.07
1.15 1.15 1.15 1.12 1.16
1.08 1.07 1.05 1.06 1.04
1.06 1.05 1.06 1.05 1.07
1.08 1.07 1.05 1.05 1.04
1.11 1.07 1.06 1.08 1.07
1.080
1.180
1.120
1.146
1.060
1.058
1.058
1.078
1.17 1.09 1.06 1.07 1.06
1.18 1.19 1.18 1.17 1.17
1.18 1.11 1.10 1.09 1.07
1.08 1.13 1.15 1.12 1.13
1.08 1.05 1.04 1.04 1.04
1.05 1.05 1.06 1.05 1.04
1.12 1.04 1.03 1.03 1.04
1.10 1.08 1.07 1.08 1.08
1.090
1.178
1.110
1.122
1.050
1.050
1.052
1.082
1.01 1.02
1.00 1.01
1.01 1.01
1.00 1.01
1.00 1.01
1.00 1.00
1.00 1.00 1.01 1.01 (continued on next page)
Average 2
20 40 60 80 100
Average 3
20 40 60 80 100
Average 4
20 40 60 80 100
Average 5
20 40 60 80 100
Average 6
20 40 60 80 100
Average 7
20 40 60 80 100
Average 8
20 40 60 80 100
Average 9
20 40
GBL
A–B
Lodi et al.
780
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781
Table 12 (continued) Class
n
60 80 100 Average 10
20 40 60 80 100
Average
FFF
GBL
A–B
Lodi et al.
2BPjOjG
2BPjRjG
2BPjOjG
2BPjRjG
2BPjOjG
2BPjRjG
2BPjOjG
2BPjRjG
1.02 1.02 1.02
1.01 1.01 1.01
1.01 1.01 1.00
1.01 1.01 1.00
1.01 1.00 1.00
1.00 1.00 1.00
1.01 1.01 1.01
1.01 1.01 1.01
1.018
1.008
1.008
1.006
1.004
1.000
1.008
1.008
1.14 1.14 1.15 1.15 1.14
1.15 1.09 1.11 1.09 1.07
1.15 1.12 1.14 1.15 1.11
1.17 1.09 1.08 1.07 1.07
1.12 1.06 1.09 1.06 1.08
1.10 1.06 1.07 1.07 1.04
1.14 1.09 1.08 1.10 1.07
1.12 1.08 1.07 1.06 1.05
1.144
1.102
1.134
1.096
1.082
1.068
1.096
1.076
2BPjOjG and 1.084 for 2BPjRjG to 1.056 and 1.036, respectively. A–B performs, on average, better than TS for the 2BPjOjG. For all classes, the average ratio of A–B is less than TS’s: it is 1.056 for A–B versus 1.079 for TS. Nevertheless, there are few exceptions (e.g., class 3, n = 60; class 7, n = 80; class 8, n = 40, 60, 80; class 9, n = 40; and class 10, n = 100). For 2BPjRjG, A–B is, on average, as good or better than TS except for class 10, n = 80. Its average ratio is 1.036 versus 1.065 for TS. The good performance of A–B in comparison to GBL or TS is due to several reasons. First, its interacting agents strive continuously towards increasing their groups’ cutting coefficients. Second, decisions are revokable since agentinitiators’ groups can be disassembled, and agents can be reassigned to new groups. Indeed, A–B’s reconstruction process maintains the ‘‘good’’ parts of the solution and rebuilds the ‘‘weaker’’ parts. Third, the pseudo-parallelism of the approach helps it better investigate the solution space. Fourth and last, its random priority lists allow it to investigate a larger part of the solution space; thus, ends up converging to a (near) optimal solution.
the exploitation and exploration of the search space. It is very fast and yields (near) optimal solutions. It solves very large problems. The major advantage of the agent-based system in comparison to a ‘‘traditional’’ algorithm is its modularity; thus, its straightforward adaptability to numerous variants of cutting and packing problems including irregular, non-guillotine, orthogonal packing, k-staged cutting, cut order planning, etc. In fact, A–B can be easily adapted to any knapsack-type optimization problem [22] such as early tardy scheduling, districting, and timetabling problems. The agents for any new problem are directly inherited from the already developed agents, and adapted to the new problem via the modification of their decision processes and properties. Therefore, the proposed agent-based algorithm, which explores well the ideas of distributed artificial intelligence and pseudo-parallelism, offers a new class of adaptive optimization algorithms that are more robust in the sense that they are less sensitive to problem parameters and more flexible than traditional approaches [19]. Its application will lead to the resolution of large scale complex optimization problems.
5. Conclusion
Acknowledgements
This paper solves the guillotine two-dimensional bin packing problem, which is NP-hard, using a constructive sequential guillotine bottom left heuristic and a pseudoparallel agent-based system. GBL successively packs items into a bin and creates a new bin every time it can no longer fit any unpacked item into the current one. It competes well with existing constructive approaches: It is very fast and yields good solutions. A–B, which is based on the concept of distributed artificial intelligence, assimilates the items to dynamically interacting agents whose decision process is governed by GBL. An agent proclaims itself an agent-initiator or a free individual-agent, and strives to optimize its individual objective. The agent-based system undertakes an intensified search for each ordering of the items, and is rerun with different priority lists to ensure, respectively,
The authors thank Aida F. Valeeva, Denis V. Popov, Elita A. Mukhacheva, and three anonymous referees for their invaluable comments. References [1] J.E. Beasley, A population heuristic for constrained two-dimensional non-guillotine cutting, European Journal of Operational Research 156 (2004) 601–627. [2] J.O. Berkey, P.Y. Wang, Two-dimensional finite bin packing algorithms, Journal of the Operational Research Society 38 (1987) 423– 429. [3] K.B. Binkley, M. Hagiwara, Applying self-adaptive evolutionary algorithms to two-dimensional packing problems using a four corners’ heuristic, European Journal of Operational Research 183 (2006) 1230–1248.
S. Polyakovsky, R. M’Hallah / European Journal of Operational Research 192 (2009) 767–781 [4] F.K.R. Chung, M.R. Garey, D.S. Johnson, On packing twodimensional bins, SIAM Journal of Algebraic and Discrete Methods 3 (1982) 66–76. [5] J.R. Correa, Near-optimal solutions to two-dimensional bin packing with 90 rotations, Electronic Notes in Discrete Mathematics 18 (2004) 89–95. [6] J.R. Correa, Resource augmentation in two-dimensional packing with orthogonal rotations, Operations Research Letters 34 (2006) 85– 93. [7] M. Dell Amico, S. Martello, D. Vigo, A lower bound for the nonoriented two-dimensional bin packing problem, Discrete Applied Mathematics 118 (2002) 13–24. [8] K. Dowsland, Some experiments with simulated annealing techniques for packing problems, European Journal of Operational Research 68 (1993) 389–399. [9] O. Faero, D. Pisinger, M. Zachariasen, Guided local search for the three-dimensional bin packing problem, INFORMS Journal on Computing 15 (2003) 267–283. [10] S.P. Fekete, J. Schepers, A general framework for bounds for higherdimensional orthogonal packing problems, Mathematical Methods of Operations Research 60 (2004) 311–329. [11] FIPA Interaction Protocol Specification. . [12] E. Hopper, B.C.H. Turton, An empirical investigation of metaheuristic and heuristic algorithms for a 2D packing problem, European Journal of Operational Research 128 (2001) 34–57. [13] A. Lodi, S. Martello, D. Vigo, Neighborhood search algorithm for the guillotine non-oriented two-dimensional bin packing problem, in: S. Voss, S. Martello, I.H. Osman, C. Roucairol (Eds.), MetaHeuristics: Advances and Trends in Local Search Paradigms for Optimization, Kluwer Academic Publishers, Boston, 1998, pp. 125– 139. [14] A. Lodi, S. Martello, D. Vigo, Approximation algorithms for the oriented two-dimensional bin packing problem, European Journal of Operational Research 112 (1999) 158–166. [15] A. Lodi, S. Martello, D. Vigo, Heuristic and metaheuristic approaches for a class of two-dimensional bin packing problems, INFORMS Journal on Computing 11 (1999) 345–357.
781
[16] A. Lodi, S. Martello, D. Vigo, Recent advances on two-dimensional bin packing problems, Discrete Applied Mathematics 123 (2002) 379– 396. [17] A. Lodi, S. Martello, D. Vigo, Two-dimensional packing problems: A survey, European Journal of Operational Research 141 (2002) 241– 252. [18] S. Martello, D. Vigo, Exact solution of the two-dimensional finite bin packing problem, Management Science 44 (1998) 388–399. [19] M. Mes, M. van der Heijden, A. van Harten, Comparison of agentbased scheduling to look-ahead heuristics for real-time transportation problems, European Journal of Operational Research 181 (2007) 59– 75. [20] E.A. Mukhacheva, A.F. Valeeva, V.M. Kartak, A.S. Filippova, Models for orthogonal packing and cutting problems: An analytical review, Application Journal of Information Technologies 5 (2004) 1– 17. [21] S.I. Parinov, Toward a theory and agent based model of the networked economy, 1999. . [22] S. Polyakovsky, R. M’Hallah, An agent-based approach to knapsack optimization problems, in: H.G. Okuno, A. Moonis (Eds.), Lecture Notes in Artificial Intelligence, vol. 4570, 2007, pp. 1098–1107. [23] J. Puchinger, G.R. Raidl, Models and algorithms for three-stage twodimensional bin packing, European Journal of Operational Research 183 (2006) 1304–1327. [24] W. Schneider, Trim-loss minimization in a crepe-rubber mill: Optimal solution versus heuristic in the 2(3)-dimensional case, European Journal of Operational Research 34 (1998) 273–281. [25] Y.G. Stoyan, Mathematical methods for geometric design, in: Advances in CAD/CAM: Proceeding PROLAMAT’82, Leningrad, USSR, 16–18 May 1982, North Holland, 2003, pp. 67–86. [26] F.G. Vasko, F.E. Wolf, K.L. Stott, A practical solution to a fuzzy two-dimensional cutting stock problem, Fuzzy Sets and Systems 29 (1989) 259–275. [27] G. Wa¨scher, H. Haussner, H. Schumann, An improved typology of cutting and packing problems, European Journal of Operational Research 183 (2007) 1109–1130.
