Elsevier

Computers & Industrial Engineering

Volume 75, September 2014, Pages 176-186
Computers & Industrial Engineering

Optimization of one-dimensional Bin Packing Problem with island parallel grouping genetic algorithms

https://doi.org/10.1016/j.cie.2014.06.002Get rights and content

Highlights

  • Novel hybrid bin-oriented heuristics with polynomial running times are proposed.

  • Parallel processing, grouping genetic algorithms, and novel hybrid bin oriented heuristics are combined.

  • A set of robust Island Parallel Genetic Algorithms are proposed.

Abstract

The well-known one-dimensional Bin Packing Problem (BPP) of whose variants arise in many real life situations is a challenging NP-Hard combinatorial optimization problem. Metaheuristics are widely used optimization tools to find (near-) optimal solutions for solving large problem instances of BPP in reasonable running times. With this study, we propose a set of robust and scalable hybrid parallel algorithms that take advantage of parallel computation techniques, evolutionary grouping genetic metaheuristics, and bin-oriented heuristics to obtain solutions for large scale one-dimensional BPP instances. A total number of 1318 benchmark problems are examined with the proposed algorithms and it is shown that optimal solutions for 88.5% of these instances can be obtained with practical optimization times while solving the rest of the problems with no more than one extra bin. When the results are compared with the existing state-of-the-art heuristics, the developed parallel hybrid grouping genetic algorithms can be considered as one of the best one-dimensional BPP algorithms in terms of computation time and solution quality.

Introduction

Many practical optimization problems require efficient grouping (clustering) of a set of items into a collection of disjoint subsets according to some specific constraints. The well-known one-dimensional Bin Packing Problem (BPP) is such a NP-hard combinatorial grouping problem that often occurs in real life including engineering, logistics, and manufacturing (Garey and Johnson, 1979, Johnson et al., 1974). The BPP appears as the main problem or a significant subproblem in a large number of industrial applications (Camacho et al., 2013, Fleszar and Charalambous, 2011, Fleszar, 2012). Two/three dimensional versions of BPP are frequently faced during manufacturing processes. For instance, in clothing, construction, glass, plastic, or metal industries, components need to be cut from the fewest sheets of material (Dahmani, Clautiaux, Krichen, & Talbi, 2013). Similarly, when designing the layout of the pages of a newspaper, the editor needs to arrange the articles on pages of fixed dimensions. In the shipping and transportation industries, packages of identical heights have to be loaded in the minimum number of rectangular bins.

Informally, the BPP is the process of packing n items into a number of same size and shape (for ease of planning and transportation) bins with a capacity of c where the objective is to minimize the number of bins required to contain n items (Gupta and Ho, 1999, Martello and Toth, 1989). The number of bins is assumed to be unlimited, each with capacity c > 0. A set of n items is to be packed into bins and the size of item i {1,,n} is si > 0, as shown in Eq. (1):k:ibin(k)sicThe goal of one-dimensional BPP is to find the minimum number of bins, M, required for packing all n items (Eq. (2)):Mi=1nsicModern parallel computation environments such as grid and high performance computing have received intensive attention from industry and academia in recent years because of their ability to solve hard problems more efficiently and accurately. In order to overcome the processing power limits, multi-core processors integrate many cores into one chip and deliver higher total computing power. By developing parallel algorithms that can efficiently use all of the available processors, the processing power supplied by multi-core processors can increase the solution quality of one-dimensional BPP (Fernandez, Gil, Banos, & Montoya, 2013).

In addition to these benefits of multi-core processors, genetic algorithms (GAs) continue to be promising tools for numerous NP-Hard optimization problems where exact solution methods tend to fail because of the exponential search spaces (Cantu-Paz, 2000, Holland, 1975, Luque and Alba, 2011, Mitchell, 1996, Zitzler and Thiele, 1999). The study of Rohlfshagen and Bullinaria (2007) that we have parallelized is such a recent technique for solving the one-dimensional BPP that views individuals as (eukaryotic) genes instead of (prokaryotic) genomes in order to improve the traditional design of GAs.

In this study, our main motivation was to solve the one dimensional BPP with island parallel grouping genetic algorithms (GGAs) that take advantage of state-of-the-art computation tools. Island parallel GAs are very efficient tools for the solution of many NP-Hard problems (Cantu-Paz, 2000, Gordon and Whitley, 1993, Lim et al., 2000, Luque and Alba, 2011). They bring many of the state-of-the-art computational tools together for better results.

With the proposed novel algorithms, we have combined state-of-the-art computation tools; parallel processing, GGAs, and bin oriented heuristics to efficiently solve the intractable one-dimensional BPP. The majority (88.5%) of the 1318 benchmark problem instances are solved optimally while the rest of the solutions produce only one extra bin. Novel hybrid bin-oriented heuristics with polynomial running times are proposed for GGAs and used to reinsert the remaining items into bins after the process of crossover and mutation. The solution quality of sequential GGAs is improved by the use of subpopulations on multi-core processors and it is shown that there is a potential to solve the BPP even more accurately if additional processors can be supplied.

In Section 2, we briefly review the relevant and the best performing sequential and parallel recent methods in chronological order. Section 3 explains the GGAs, canonical GA crossovers, Falkenauer’s crossover, molecular genetics exon shuffling crossover, mutation, and inversion operator. Section 4 gives brief information about the use of BPP heuristics in the developed algorithms. Section 5 defines the proposed parallel hybrid GGAs and the parameter settings. Experimental comparisons of the developed algorithms are given in Section 6. Finally, conclusions and further research directions are discussed in Section 7.

Section snippets

Related work

One-dimensional BPP has been solved by numerous heuristics and exact techniques. A classical reference for the BPP is the book by Martello and Toth (1990), in which they describe a number of simple heuristics and lower bounds, introduce a reduction procedure (MTRP), and an exact algorithm (MTP). Best-Fit-Decreasing (BFD) and the First-Fit-Decreasing (FFD) algorithms are the two best known heuristics. Both heuristics sort items in decreasing order and place the largest item in either the first

Grouping genetic algorithms for one dimensional Bin Packing Problem

A group is defined as a set of similar objects on which a measure of similarity can be defined. The grouping satisfies the constraints that limit the groups into which a given item can be placed (Falkenauer, 1994). The goal of optimization is to find the grouping with the minimum cost. In this section, we give information about the solution representation (chromosome) of Holland-style and Falkenauer’s chromosomes, degeneracy, crossover, mutation, and inversion.

Bin-oriented heuristics for one-dimensional BPP

In this section, we give information about the well-known minimum bin slack (MBS) heuristic and our proposed hybrid heuristics, MBS with Best First Decreasing (MBS-BFD) and MBS with First Fit Decreasing (MBS-FFD). The computation time of the proposed heuristics has polynomial complexity instead of exponential and provides a good reinsertion mechanism when the search space of MBS becomes prohibitively large.

Description of proposed algorithms

In this section, we give information about eight different parallel hybrid GGAs that we have proposed for the solution of one-dimensional BPP. Our main goal with the proposed algorithms is to take advantage of multiprocessors to generate several non-redundant populations and explore the search space more efficiently rather than reducing the optimization time of GGA with a single population by calculating the fitness values with different processors. We have developed algorithms with two types

Experimental results and discussion

In this section, we give information about the environment of our experiments (high performance cluster (HPC) machine), problem instances, parameter settings, performance evaluations (in terms of execution time and produced results), robustness, and scalability of the proposed algorithms. In the last part, we report the results of the best performing algorithm (Exon-MBS-BFD) with 1318 problem instances and compare its performance on the hard28 (Belov, Scheithauer, & Mukhacheva, 2007) problem

Conclusions and future work

One-dimensional Bin Packing (BPP) is an NP-hard combinatorial optimization problem with many practical applications in real life. Grouping genetic algorithms (GGAs) are robust tools to optimize this well-known problem when the conventional exact solution methods tend to fail. Although GGAs work well in combination with the problem specific heuristics, they do not make best use of the abilities of the multi-core processors. This paper reports the results of our efforts to increase the solution

References (59)

  • K.-H. Loh et al.

    Solving the one-dimensional bin packing problem with a weight annealing heuristic

    Computers and Operations Research

    (2008)
  • A. Scholl et al.

    BISON: A fast hybrid procedure for exactly solving the one-dimensional bin packing problem

    Computers and Operations Research

    (1997)
  • P. Schwerin et al.

    The bin-packing problem: A problem generator and some numerical experiments with FFD packing and MTP

    International Transactions in Operational Research

    (1997)
  • A. Stawowy

    Evolutionary based heuristic for bin packing problem

    Computers & Industrial Engineering

    (2008)
  • A.C.F. Alvim et al.

    A hybrid improvement heuristic for the one-dimensional bin packing problem

    Journal of Heuristics

    (2004)
  • G. Belov et al.

    One-dimensional heuristics adapted for two-dimensional rectangular strip packing

    Journal of the Operational Research Society

    (2007)
  • J.O. Berkey et al.

    A systolic-based parallel bin packing algorithm

    IEEE Transactions on Parallel and Distributed Systems

    (1994)
  • Bestavros, A., Cheatham, T., Jr., & Stefanescu, D. (1990). Parallel bin packing using first fit and k-delayed best-fit...
  • A.K. Bhatia et al.

    Packing bins using multi-chromosomal genetic representation and better fit heuristic

    Lecture Notes in Computer Science

    (2004)
  • E.L. Camacho et al.

    Understanding the structure of bin packing problems through principal component analysis

    International Journal of Production Economics

    (2013)
  • E. Cantu-Paz

    Efficient and accurate parallel genetic algorithms

    (2000)
  • Coffman, E. G., Galambos, G., Martello, S., & Vigo, D. (1999). Bin packing approximation algorithms: Combinatorial...
  • E.G. Coffman et al.

    Approximation algorithm for bin packing: A survey

  • N.S. Coleman et al.

    An asymptotically optimal parallel bin-packing algorithm

  • Ding, H., El-Keib, A. A., & Smith, R. E. (1992). Optimal clustering of power networks using genetic algorithms TCGA...
  • T. Dokeroglu et al.

    Evolutionary multiobjective query workload optimization of cloud data warehouses

    The Scientific World Journal

    (2014)
  • E. Falkenauer

    A new representation and operators for GAs applied to grouping problems

    Evolutionary Computation

    (1994)
  • E. Falkenauer

    A hybrid grouping genetic algorithm for bin packing

    Journal of Heuristics

    (1996)
  • K. Fleszar

    Three insertion heuristics and a justification improvement heuristic for two-dimensional bin packing with guillotine cuts

    Computers and Operations Research

    (2012)
  • Cited by (0)

    This manuscript was processed by Area Editor Mitsuo Gen.

    View full text