An effective shuffled frog-leaping algorithm for lot ... - CiteSeerX

11 downloads 0 Views 361KB Size Report
Jan 23, 2010 - Abstract This paper presents an effective shuffled frog- leaping algorithm (SFLA) for solving a lot-streaming flow shop scheduling problem with ...
Int J Adv Manuf Technol DOI 10.1007/s00170-010-2775-3

ORIGINAL ARTICLE

An effective shuffled frog-leaping algorithm for lot-streaming flow shop scheduling problem Quan-Ke Pan & Ling Wang & Liang Gao & Junqing Li

Received: 23 January 2010 / Accepted: 7 June 2010 # Springer-Verlag London Limited 2010

Abstract This paper presents an effective shuffled frogleaping algorithm (SFLA) for solving a lot-streaming flow shop scheduling problem with equal-size sublots, where a criterion is to minimize maximum completion time (i.e., makespan) under both an idling and no-idling production cases. Unlike the original SFLA, the proposed SFLA represents an individual or frog as a job permutation and utilizes a position-based crossover operator to generate new candidate solutions. An efficient initialization scheme based on the Nawaz–Enscore–Ham heuristic is proposed to construct an initial population with a certain level of quality and diversity. A simple but effective local search approach is embedded in SFLA to enhance the local intensification capability. In addition, a speed-up method to evaluate insert neighborhood is presented to improve the algorithm’s efficiency. Extensive computational experiments and comparisons are provided, which demonstrate the effectiveness of the proposed SFLA against the best performing algorithms from the literature.

Q.-K. Pan (*) : J. Li College of Computer Science, Liaocheng University, Liaocheng 252059, People’s Republic of China e-mail: [email protected] L. Wang Tsinghua National Laboratory for Information Science and Technology (TNList), Department of Automation, Tsinghua University, Beijing 100084, China L. Gao State Key Lab. of Digital Manufacturing Equipment and Technology in Huazhong University of Science and Technology, Wuhan 430074, People’s Republic of China

Keywords Flow shop scheduling . Lot-streaming . Shuffled frog-leaping algorithm . Makespan . Speed-up evaluation

1 Introduction Among all types of scheduling problems, lot-streaming flow shop has important applications in most practical production systems [1, 2]. In a lot-streaming flow shop, n number of jobs will be processed on m machines in the sequence of the machine arrangement. Each job consists of many identical items. In order to reduce machine waiting time to accelerate production, a job is allowed to overlap its operations between successive machines by splitting it into a number of smaller sublots and moving the completed portion of the sublots to downstream machines [3]. The job splitting into sublots process is usually called lot-streaming, which is one of effective techniques used to implement the time-based strategy in today’s era of global competition [4]. This paper addresses an n-job, m-machine lot-streaming flow shop scheduling problem with equal-size sublots to minimize the maximum completion time (i.e., makespan). Two different production cases, namely, an idling case and no-idling case, are considered. The no-idling case is one where a job must be continuously processed without production interruption time (i.e., idle time) between any two adjacent sublots at the same stage, whereas the idling case allows idle time on machines [4]. In recent years, lot streaming has received extensive attention and been applied to flow shop scheduling problems [5]. A comprehensive review of scheduling problems involving lot-streaming can be found in [4]. For single-job lot-streaming flow shop problems, Baker and Jia [6] showed that makespan was improved with an

Int J Adv Manuf Technol

increasing number of sublots. Trietsch and Baker [7] generalized some important structural insights by reviewing the different forms of single-job lot-streaming in the literature. With regarding to total flow time criterion, Kropp and Smunt [8] presented optimal sublot size policies and two heuristic methods. Bukchin et al. [9] proposed optimal solution properties and developed a solution procedure for a two-machine flow shop scheduling problem with sublot detached setups and batch availability. Recently, Liu [10] investigated the continuous version of the problem. Edis and Ornek [11] proposed a heuristic to minimize makespan for a single-product multistage stochastic flow shop problem with consistent sublot types and discrete sublot sizes. For multi-job lot-streaming flow shop problems, Vickson and Alfredsson [12] studied the effect of transfer batch in a two-machine and special three-machine problems with unitsize sublots. Cetinkaya [13] proposed an optimal transfer batch and scheduling algorithm for a two-stage problem with setup, processing, and removal times, respectively. Vickson [14] examined a two-machine problem involving setup and sublot transfer times with respect to both continuous and integer valued sublot sizes. Sriskandarajah and Wagneur [15] presented an efficient heuristic for solving the problem of simultaneous lot-streaming and scheduling of multiple products in a two-machine no-wait flow shop. With respect to the m-machine flow shop scheduling problems, Kumar et al. [16] extended the approach presented by Sriskandarajah and Wagneur [15] to an m-machine case. Kalir and Sarin [17] proposed a bottleneck minimal idleness heuristic to sequence a set of batches to be processed in equal sublots for minimizing makespan. Yoon and Ventura [18] presented 16 pairwise interchange methods to optimize mean weighted absolute deviation from due dates. In most lot-streaming flow shop scheduling problems, the computational effort required to solve an instance of a problem grows very quickly as the number of jobs increases [3]. Therefore, with the development of computer technology, meta-heuristics have been increasingly applied to lotstreaming flow shop problems. Marimuthu and Ponnambalam [19] proposed a genetic algorithm (GA) and simulated annealing for lot streaming in a two-machine flow shop to minimize makespan. Yoon and Ventura [3] presented a hybrid GA for an n-job m-machine lot-streaming flow shop to minimize the mean weighted absolute deviation of job completion times from due dates. Recently, Tseng and Liao [5] developed a discrete particle swarm optimization (PSO) for solving an n-job, m-machine lot-streaming problem with equal-size sublots where the objective is to minimize the total weighted earliness and tardiness. More recently, Martin [20] presented a hybrid genetic algorithm/mathematical programming approach to minimize makespan for a multifamily flow shop scheduling problem with lot-streaming. To deal with both makespan and total flow time criteria for an

n-job m-machine lot-streaming flow shop problem involving setup time, Marimuthu et al. first proposed a genetic algorithm and hybrid genetic algorithm (HGA) in [1] and then developed an ant colony optimization (ACO) and threshold accepting (TA) algorithms in [2]. In general, evolutionary algorithms are stochastic optimizing techniques that mimic a natural biological evolution or social behavior of species [20–22]. Recently, inspired by natural memetics, a shuffled frog-leaping algorithm (SFLA) was developed by Eusuff et al. [23, 24] for solving combinatorial optimization problems. Due to its effectiveness and suitability, SFLA has captured much attention and been applied to solve many practical optimization problems [22–28]. To the best of our knowledge, there is no published work dealing with the lot-streaming flow shop scheduling by using SFLA. Thus, in this paper we present an effective SFLA variant for solving the problem with a criterion to minimize the maximum completion time, i.e., makespan. Furthermore, both no-idling case and idling case between any two adjacent sublots of a job at the same stage are considered, respectively. As in [1] and [2], we assume equalsize sublots and infinite capacity buffers between successive machines, and the setting of first sublot of each job on a machine consumes a setup time on its arrival to this machine. Computational experiments and comparisons show that the proposed SFLA outperforms three best performing algorithms proposed recently for solving the lot-streaming flow shop scheduling problem with the makespan criterion. The rest of the paper is organized as follows. In Section 2, the lot-streaming flow shop scheduling problem with equalsize sublots is stated and formulated. In Section 3, the speedup method for the insert neighborhood structure is proposed. Section 4 gives a brief introduction to the basic SFLA. Section 5 proposes a SFLA variant for lot-streaming flow shop problem in detail. The computational results and comparisons are provided in Section 6, and finally we end the paper with some concluding remarks in Section 7.

2 Lot-streaming flow shop scheduling problem The problem considered in this research is the minimization of the maximum completion time for an n-job, m-machine lot-streaming flow shop scheduling with equal-size sublots for a job on all the machines. Each job j∊J={1,2,...,n} will be sequentially processed on m machines, and the job sequence is the same on each machine i∊M={1,2,...,m}. In order to reduce lead time and to accelerate production, each job j can be split into l( j) number of smaller sublots with equal size such that l( j) is the same for all the machines. Once the processing of a sublot on a machine is completed, it can be transferred to a downstream machine immediately. However, all the l( j) sublots of job j should be processed

Int J Adv Manuf Technol

units (see in Fig. 1a). If the job is split into three sublots and no-idling production interruption time is allowed between any two adjacent sublots, the job completion time is reduced to 13 time units (see in Fig. 1 b), whereas for the idling case, the job completion time is further reduced to 12 time units (see in Fig. 1c). Clearly, the completion time of the job under the idling case is shorter than the one under the no-idling case with the same sublot type. However, there are also many practical applications for the lotstreaming flow shop scheduling under no-idling case [4]. Therefore, both the idling and no-idling cases are considered in this paper.

t

a

t

b

2.1 Calculation of makespan in no-idling case The formulation of makespan consists of forward and backward passes to facilitate a speed-up method presented in Section 3. Let a job permutation : ={: 1, : 2,...,: n} represent a schedule of jobs to be processed, ST (k, j, e) denote the earliest start time of machine k serving the eth sublot of job j, CT (k, j, e) be the earliest completion time of the eth sublot of job j on machine k, and Cmax (: ) be the makespan of the permutation : . Then the forward pass calculation (see an example in Fig. 2) is described as follows:

c Fig. 1 An example for the lot-streaming scheduling problem

continuously. Under the no-idling constraint, there is noidling production interruption time between any two adjacent sublots of job j at the same stage, whereas the idling case allows idle times. Furthermore, at any time, each machine can process at most one sublot, and each sublot can be processed on at most one machine. Let the processing time of each sublot of job j on machine i be p (i, j), and the setting of first sublot of each job j on machine i consumes a time of s(i, j) on its arrival to that machine. Given that the release time of all jobs is zero and sublot transportation time is included in the processing time, then the objective is to find a sequence with the optimal sublot starting and completion times to minimize the maximum completion time. An example of a single job, three equal-size sublots, three-machine flow shop scheduling with the job processing times of 6, 3, and 6 time units and job setup times of 1, 1, and 1 time units is shown in Fig. 1. If the job is not split into sublots, the job completion time is 18 time Fig. 2 Forward pass calculation of makespan in no-idling case



STð1; p1 ; 1Þ ¼ 0 CTð1; p1 ; l ðp 1 ÞÞ ¼ STð1; p1 ; 1Þ þ sð1; p 1 Þ þ lðp1 Þ  pð1; p1 Þ

ð1Þ 8 STðk; p 1 ; 1Þ ¼ maxfSTðk  1; p 1 ; 1Þ þ sðk  1; p 1 Þ > > > > > > þpðk  1; p 1 Þ; CTðk  1; p 1 ; l ðp 1 ÞÞ > < sðk; p 1 Þ  ðl ðp 1 Þ  1Þ  pðk; p 1 Þg > > > > CTðk; p 1 ; l ðp 1 ÞÞ ¼ STðk; p 1 ; 1Þ þ sðk; p 1 Þ þ l ðp 1 Þ > > > :  pðk; p 1 Þ k ¼ 2; 3; :::; m ð2Þ 8 < STð1; p i ; 1Þ ¼ CTð1; p i1 ; l ðp i1 ÞÞ CTð1; p i ; l ðp i ÞÞ ¼ STð1; p i ; 1Þ þ sð1; p i Þ þ l ðp i Þ  pð1; p i Þ : i ¼ 2; 3; :::; n ð3Þ

machine

ST(3,1,2) ST(3,1,1) 3

s(3,1)

2 1

s(2,1) s(1,1)

p(1,1)

p(1,1)

s(1,2)

p(3,1)

p(1,2)

s(1,3)

s(3,2)

p(3,1)

p(2,1)

p(2,1)

s(2,2) p(1,3)

p(2,2)

p(3,2)

s(2,3)

p(2,3)

s(3,3)

p(3,3)

p(3,3)

p(2,3)

p(1,3) t

ST(1,3,1) CT(1,3,1) makespan

Int J Adv Manuf Technol

8 STðk; p i ; 1Þ ¼ maxfSTðk  1; p i ; 1Þ þ sðk  1; p i Þ > > > > > þpðk  1; p i Þ; CTðk  1; p i ; l ðp i ÞÞ > > < sðk; p i Þ  ðlðp i Þ  1Þ  pðk; p i Þ; > > CTðk; p i1 ; l ðp i1 ÞÞg > > > > CT k; p ð ; l ð p Þ Þ ¼ STðk; p i ; 1Þ þ sðk; p i Þ þ l ðp i Þpðk; p i Þ > i i : i ¼ 2; 3; :::; n; k ¼ 2; 3; :::; m ð4Þ ð5Þ

Cmax ðp Þ ¼ CTðm; p n ; l ðp n ÞÞ

On the above formulations, only ST(k, : i, 1) and CT(k, πi, l(πi)) are considered, since there is no-idling production interruption time between any two adjacent sublots of job πi, and it is easy to get the start time and completion time of other sublots for job πi from the obtained ST(k,: i,1) and CT(k, : i, l (: i)). Note that in the Eqs. 2 and 4, STðk  1; p 1 ; 1Þ þ sðk  1; p 1 Þ þ pðk  1; p 1 Þ and STðk  1; p i ; 1Þ þ sðk  1; p i Þ þ pðk  1; p i Þ ensure that a machine can serve a job only after its first sublot arrives the machine, and CTðk  1; p 1 ; l ðp 1 ÞÞ  sðk; p 1 Þ  ðl ðp 1 Þ  1Þ  pðk; p 1 Þ, and CTðk  1; p i ; l ðp i ÞÞ  sðk; p i Þ  ðl ðp i Þ  1Þ  pðk; p i Þ satisfy the no-idling condition between any two adjacent sublots of a job at same stage, and CT(k, : i−1, l(: i−1)) meets the constraint that each machine can process at most one job at a time. Correspondingly, let CTb(k, j, e) be the latest completion time of the eth sublot of job j on machine k, STb(k, j, e) denote the latest start time of the machine k serving on the eth sublot of job j. Then, the makespan of permutation π can be calculated in the following alternative method (see an example in Fig. 3). 8 > CTbðm; p n ; l ðp n ÞÞ ¼ 0 > < STbðm; p n ; 1Þ ¼ CTbðm; p n ; l ðp n ÞÞ þ sðm; p n Þ þ l ðp n Þ > > :  pðm; p Þ n

ð6Þ 8 CTb k; p ð ; l ð p Þ Þ ¼ maxfSTb ð k þ 1; p ; 1 Þ  ð l ð p Þ  1Þ > n n n n > > > > >  pðk; p n Þðk þ 1; p n ; l ðp n ÞÞ > < þpðk þ 1; p n Þ > STbðk; p n ; l ðp n ÞÞ ¼ CTbðk; p n ; l ðp n ÞÞ þ sðk; p n Þ þ l ðp n Þ > > > > >  pðk; p n Þ > : k ¼ m  1; m  2; :::1

8 CTbðm; p i ; l ðp i ÞÞ ¼ STbðm; p iþ1 ; l ðp iþ1 ÞÞ > > > > < STbðm; p i ; 1Þ ¼ CTbðm; p i ; l ðp i ÞÞ þ sðm; p i Þ þ l ðp i Þ > > > > :

 pðm; p i Þ i ¼ n  1; n  2; :::; 1

ð8Þ 8 CTbðk; p i ; l ðp i ÞÞ ¼ maxfSTbðk þ 1; p i ; 1Þ  ðl ðp i Þ  1Þ > > > > > >  pðk; p i Þ; CTbðk þ 1; p i ; l ðp i ÞÞ > > > > < þpðk þ 1; p i Þ; STbðk; p iþ1 ; 1Þg > STbðk; p i ; l ðp i ÞÞ ¼ CTbðk; p i ; l ðp i ÞÞ þ sðk; p i Þ þ l ðp i Þ > > > > > >  pðk; p i Þ > > > : i ¼ n  1; n  2; :::; 1; k ¼ m  1; m  2; :::1 ð9Þ Cmax ðp Þ ¼ STbð1; p 1 ; 1Þ

ð10Þ

2.2 Calculation of makespan in idling case Like the calculation of makespan in the no-idling case, we present both forward and backward passes to calculate makespan in idling case. Let a job permutation : ={: 1, : 2,...,: n} represent the schedule of jobs to be processed, ST (k, j, e) denote the earliest start time of the machine k serving on the eth sublot of job j, CT(k, j, e) be the earliest completion time of the eth sublot of job j on machine k, and Cmax(: ) be the makespan of the permutation : . The forward pass calculation is given as follows (see an example in Fig. 4). 8 STð1; p 1 ; 1Þ ¼ 0 > > > > < CTð1; p 1 ; 1Þ ¼ STð1; p 1 ; 1Þ þ sð1; p 1 Þ þ pð1; p 1 Þ STðk; p 1 ; 1Þ ¼ CTðk  1; p 1 ; 1Þ > > CT ðk; p 1 ; 1Þ ¼ STðk; p 1 ; 1Þ þ sðk; p 1 Þ þ pðk; p 1 Þ > > : k ¼ 2; 3; :::m

ð11Þ

8 STð1; p 1 ; eÞ ¼ CTð1; p 1 ; e  1Þ > > > > < CTð1; p 1 ; eÞ ¼ STð1; p 1 ; eÞ þ pð1; p 1 Þ STðk; p 1 ; eÞ ¼ maxfCTðk  1; p 1 ; eÞ; CTðk; p 1 ; e  1Þg > > > CTðk; p 1 ; eÞ ¼ STðk; p 1 ; eÞ þ pðk; p 1 Þ > : e ¼ 2; 3; :::; l ðp 1 Þ; k ¼ 2; 3; :::m ð12Þ

ð7Þ Fig. 3 Backward pass calculation of makespan in no-idling case

machine STb(3,1,1) STb(3,1,2) s(3,1) s(2,1) s(1,1)

p(1,1)

p(1,1)

p(2,1) s(1,2)

p(1,2)

p(2,1) s(1,3)

p(3,1)

p(3,1)

s(3,2)

p(3,2)

s(3,3)

s(2,2)

p(2,2)

s(2,3)

p(2,3)

p(2,3)

p(1,3)

p(1,3)

t STb(1,3,1)

p(3,3)

3 2 1

CTb(1,3,1)

makespan

p(3,3)

Int J Adv Manuf Technol Fig. 4 Forward pass calculation of makespan in idling case

machine

ST(3,1,2) ST(3,1,1) 3

s(3,1)

2 1

p(2,1)

s(2,1) s(1,1)

p(1,1)

s(1,2)

p(1,1)

p(3,1)

p(3,1) s(2,2)

p(2,1) s(1,3)

p(1,2)

p(2,2)

s(3,2)

p(3,2)

s(2,3)

p(2,3)

s(3,3)

p(3,3)

p(3,3)

p(2,3)

p(1,3)

p(1,3)

t

ST(1,3,1) CT(1,3,1) makespan

8 STð1; p i ; 1Þ ¼ CTð1; p i1 ; l ðp i1 ÞÞ > > > > CT < ð1; p i ; 1Þ ¼ STð1; p i ; 1Þ þ sð1; p i Þ þ pð1; p 1 Þ STðk; p i ; 1Þ ¼ maxfCTðk  1; p i ; 1Þ; CTðk; p i1 ; l ðp i1 ÞÞg > > CTðk; p i ; 1Þ ¼ STðk; p i ; 1Þ þ sðk; p i Þ þ pðk; p i Þ > > : i ¼ 2; 3; :::; n; k ¼ 2; 3; :::m

8 CTbðm; p n ; 1Þ ¼ STbðm; p n ; 2Þ > > > > < STbðm; p n ; 1Þ ¼ CTbðm; p n ; 1Þ þ pðm; p n Þ þ sðm; p n Þ CTbðk; p n ; 1Þ ¼ maxfSTbðk þ 1; p n ; 1Þ; STbðk; p n ; 2Þg > > STbðk; p n ; 1Þ ¼ CTbðk; p n ; 1Þ þ pðk; p n Þ þ sk; p n > > : k ¼ m  1; m  2; :::; 1

ð13Þ 8 STð1; p i ; eÞ ¼ CTð1; p i ; e  1Þ > > > > < CTð1; p i ; eÞ ¼ STð1; p i ; eÞ þ pð1; p i Þ STðk; p i ; eÞ ¼ maxfCTðk  1; p i ; eÞ; CTðk; p i ; e  1Þg > > CTðk; p i ; eÞ ¼ STðk; p i ; eÞ þ pðk; p i Þ > > : i ¼ 2; 3; :::; n; e ¼ 2; 3; :::; l ðp i Þ; k ¼ 2; 3; :::m

8 CTbðm; pi ; l ðp i ÞÞ ¼ STbðm; p iþ1 ; 1Þ > > > > < STbðm; p i ; l ðpi ÞÞ ¼ CTbðm; p i ; l ðpi ÞÞ þ pðm; p i Þ CTbðk; p i ; l ðpi ÞÞ ¼ maxðSTbðk þ 1; pi ; l ðp i ÞÞ; STbðk; p iþ1 ; 1ÞÞ > > > STbðk; pi ; l ðp i ÞÞ ¼ CTbðk; pi ; l ðp i ÞÞ þ pðk; p i Þ > : i ¼ n  1; n  2; :::; 1; k ¼ m  1; m  2; :::; 1

ð18Þ

ð19Þ 8 CTb ð m; p ; e Þ ¼ STb ð m; p ; e þ 1 Þ i i > > > > > STbðm; p i ; eÞ ¼ CTbðm; p i ; eÞ þ pðm; pi Þ > > > > < CTbðk; pi ; eÞ ¼ maxfSTbðk þ 1; p i ; eÞ; STbðk; pi ; e þ 1Þg STbðk; pi ; eÞ ¼ CTbðk; pi ; eÞ þ pðk; p i Þ > > > > > > e ¼ l ðp i Þ  1; l ðpi Þ  2; :::; 2; k ¼ m  1; m  2; :::; 1; > > > : i ¼ n  1; n  2; :::; 1

ð14Þ Cmax ðp Þ ¼ CTðm; p n ; l ðp n ÞÞ

ð15Þ

Correspondingly, let CTb(k, j, e) be the latest completion time of the eth sublot of job j on machine k and STb(k, j, e) denote the latest start time of the machine k serving on the eth sublot of job j. Then, the makespan of permutation : can be calculated below (see an example in Fig. 5).

ð20Þ 8 CTbðm; p i ; 1Þ ¼ STbðm; p i ; 2Þ > > > > < STbðm; p i ; 1Þ ¼ CTbðm; p i ; 1Þ þ pðm; p i Þ þ sðm; p i Þ CTbðk; p i ; 1Þ ¼ maxfSTbðk þ 1; p i ; 1Þ; STbðk; p i ; 2Þg > > STb ðk; p i ; 1Þ ¼ CTbðk; p i ; 1Þ þ pðk; p i Þ þ sðk; p i Þ > > : k ¼ m  1; m  2; :::; 1; i ¼ n  1; n  2; :::; 1

8 CTbðm; p n ; l ðp n ÞÞ ¼ 0 > > > > < STbðm; p n ; l ðp n ÞÞ ¼ CTbðm; p n ; l ðp n ÞÞ þ pðm; p n Þ CTbðk; p n ; l ðp n ÞÞ ¼ STbðk þ 1; p n ; l ðp n ÞÞ > > STb ðk; p n ; l ðp n ÞÞ ¼ CTbðk; p n ; l ðp n ÞÞ þ pðk; p n Þ > > : k ¼ m  1; m  2; :::; 1 ð16Þ 8 CTb m; p ð ; e Þ ¼ STb ð m; p ; e þ 1 Þ > n n > > > < STbðm; p n ; eÞ ¼ CTbðm; p n ; eÞ þ pðm; p n Þ CTbðk; p n ; eÞ ¼ maxfSTbðk þ1; p n ; eÞ; STbðk; p n ; eþ1Þg > > STbðk; p n ; eÞ ¼ CTbðk; p n ; eÞ þ pðk; p n Þ > > : e ¼ l ðp n Þ  1; l ðp n Þ  2; :::; 2; k ¼ m  1; m  2; :::; 1

ð21Þ ð22Þ

Cmax ðp Þ ¼ STbð1; p 1 ; 1Þ

The objective of the lot-streaming flow shop scheduling problem with makespan criterion is to find a permutation : * in the set of all permutations П such that  » ð23Þ Cmax p  Cmax ðp Þ; 8p 2 Π

ð17Þ Fig. 5 Backward pass calculation of makespan in idling case

machine STb(3,1,1) STb(3,1,2) s(3,1) s(2,1) s(1,1)

p(1,1)

p(1,1)

p(2,1) s(1,2)

p(2,1) p(1,2)

s(1,3)

p(3,1)

p(3,1)

s(3,2)

p(3,2)

s(2,2)

p(2,2)

s(2,3)

p(2,3)

p(1,3)

s(3,3)

p(2,3)

p(1,3)

t

CTb(1,3,1) STb(1,3,1) makespan

p(3,3)

p(3,3)

3 2 1

Int J Adv Manuf Technol Fig. 6 Speed-up method in no-idling case (insert job 2 at the position 2 of the permutation {1,3})

machine CT(3,2,1) CT(2,2,1) CT(1,2,1)

3

s(3,1)

2 1

s(2,1) s(1,1)

p(1,1)

p(1,1)

p(2,1)

p(3,1)

p(2,1)

s(1,2)

p(1,2)

s(1,3)

p(3,1) s(2,2)

s(3,2) p(2,2)

p(1,3)

p(3,2)

s(2,3)

s(3,3)

p(2,3)

p(3,3)

p(3,3)

p(2,3)

p(1,3) STb(3,3,1)

t

STb(2,3,1) STb(1,3,1) makespan

 00 Step 4 Get STb k; p z ;1 Þ for z=n−1, n−2,...,1 and k=m−1, m−2,...,1 by using Eqs. 6–9. Step 5 Repeat the following sub-steps until all possible positions q, q 2 ½1; 2; :::; n ^ q= 2fi; i  1g, of the permutation : '' are considered.

Moreover, it can be easily seen from the above recursive formulations that the time computational complexity of each calculations is O(mn). 3 Insert neighborhood based speed-up method Insert neighborhood of a job permutation : ={: 1, : 2,...,: n} is widely used for flow shop scheduling problems in the literature [29], which is defined by considering all possible insert moves in the set V ¼ fvði; qÞji 2 f1; 2; :::; ng; q 2 2fi; i  1gg. The insert move v (i, q) generf1; 2; :::; ng ^ q= ates a permutation π′ from the permutation : by removing a job πi from its original position i and inserting it into another position q, q 2 f1; 2; :::; ng ^ q= 2fi; i  1g. The number of neighbors in the insert neighborhood of a permutation π is (n−1)2, so the computational complexity to evaluate the whole insert neighborhood for the lot-streaming flow shop is O(mn3) in both the no-idling and idling cases by using the calculations of makespan presented in Section 2. However, making use of the similarity of the permutation : and its neighbor : '., Taillard [30] presented a reduction of computational complexity for evaluating an insertion neighborhood for the traditional flow shop problem. Here we extend it to the problems considered in this paper. For the no-idling case, the speed-up procedure is described as follows. Step 1 Let i=1.  00 00  00 Step 2 Let p 00 ¼ p1 ; p 2 ; :::; p n1 be a partial permutation generated by removing job : i from the permutation :.  00  00  Step 3 Get CT k; p z ; l p z for z=1,2,...,n−1 and k=1,2,..., m by using Eqs. 1–4. Fig. 7 Speed-up method in idling case (insert job 2 at the position 2 of the permutation {1,3})

Step 5.1 Insert job : i into position q and generate a permutation : '. 0  0  k; p q ; l p q Step 5.2 Calculate CT   0 by using the ob0 tained CT k; pq1 ; l pq1 and Eqs. 1–4, 0 where k=1,2,...,m. Note that p q ¼ p i . Step 5.3 The makespan of the permutation π′ is given as follows (illustrated by Fig. 6).    00   0  0 Cmax ðp Þ ¼ maxm þ STb k; p q ; 1 : k¼1 CT k; p q ; l p q Step 6 Let i=i+1. If i>n, then stop; otherwise go back to step 2. There are n iterations for steps 3, 4, and 5, and each of these steps can be executed in time O(mn). So, the computational complexity of this speed-up method to evaluate the whole insert neighborhood of the permutation π in the no-idling case is O(mn2). Correspondingly, the speed-up procedure for the idling case is described as follows. Step 1 Let i=1.   00 00 00 Step 2 Let p00 ¼ p 1 ; p 2 ; :::; p n1 be a partial permutation generated by removing job πi from the permutation π.  00   00  Step 3 Get CT k; p z ; e for z=1,2,...,n−1; e ¼ 1; 2; :::; l pz ; k=1,2,...,m by using Eqs. 11–14.

machine CT(3,2,1) CT(2,2,1) CT(1,2,1) 3

s(3,1)

2 1

s(2,1) s(1,1)

p(1,1)

p(1,1)

s(1,2)

p(3,1) p(2,1)

p(2,1) p(1,2)

s(1,3)

p(3,1) s(2,2)

p(2,2)

s(3,2)

p(3,2)

s(2,3)

p(2,3)

s(3,3)

p(3,3)

p(1,3)

p(1,3)

STb(3,3,1) STb(2,3,1) STb(1,3,1) makespan

p(3,3)

p(2,3)

t

Int J Adv Manuf Technol

x(w) U px Fig. 8 Position-based crossover operator

 00   00  Step 4 Get  00 STb k; p z ; e for z=n−1, n−2,...,1; e ¼ l p z ; l p z  1; :::; 1; k = m − 1, m − 2,...,1 by using Eqs. 16–21. Step 5 Repeat the following sub-steps until all possible positions q, q∈{1,2,...,n}∧q∉{i, i−1}, of the permutation : '' are considered.

Step 5.1 Insert job : i into position q and generate a permutation : '.  0 CT k; p q ; e by using the obtained Step 5.2 Calculate   0  0 CT k; p q1 ; l p q1 and Eqs. 11–14,  0  where k = 1,2,...,m and e ¼ 1; 2; :::; l p q . Note 0 that p q ¼ p i . Step 5.3 The makespan of the permutation : ' is given as follows (illustrated by Fig. 7).    0   00  0 Cmax ðp Þ ¼ maxm CT k; p ; l p Þ þ STb k; p q ; 1 q q k¼1 Step 6 Let i=i+1. If i>n, then stop; otherwise go back to step 2. The computational complexity of the speed-up method in idling case is also O(mn)2 to evaluate the whole insert neighborhood of the permutation : .

Table 1 Comparison of different algorithms under no-idling case n×m

SFLA

HGA

ACO

TAswap

TAinsert

ARPI

SD

ARPI

SD

ARPI

SD

ARPI

SD

ARPI

SD

10×5 10×10 10×15

0 0 0

0 0 0

0.8187 0.1524 0

0.5643 0.2086 0

0.6839 0.3528 0.0324

0.6429 0.3364 0.1024

1.2124 0.6816 1.3472

0.5171 0.3100 1.6588

2.1244 0.7137 2.8886

0.6145 0.5078 1.8148

10×20 20×5 20×10 20×15 20×20 30×5 30×10 30×15 30×20 40×5 40×10 40×15 40×20 50×5 50×10 50×15 50×20 70×5

0 0 0.0691 0.2739 0.0870 0 0 0.5875 0.2914 0 0.3341 0.4764 0.2943 0.0199 0.4851 0.5366 0.6055 0

0 0 0.1884 0.2204 0.1431 0 0 0.3580 0.2438 0 0.2903 0.2586 0.1939 0.0420 0.6262 0.3645 0.3375 0

0.5782 0.3123 0.7926 1.2888 1.8768 0 0.3970 2.6848 2.0122 0 2.1221 2.7250 2.6353 0.0598 1.2127 2.0856 3.0432 0.0018

0.7553 0.3292 0.6388 0.4701 0.6880 0 0.3025 1.0157 0.6623 0 0.4626 0.6088 0.7882 0.0514 0.0000 0.4985 0.6464 0.0056

0.9690 0.4164 1.4101 1.2002 1.6413 0 0.3769 3.0638 1.9456 0 1.6183 1.9410 1.8474 0.0896 1.1521 1.5490 1.7467 0

0.7411 0.2945 1.3413 0.6454 0.9459 0 0.2737 0.6787 0.3106 0 0.6784 0.7521 0.6324 0.0315 0.1837 0.9665 0.6058 0

1.6702 1.0151 2.9401 2.3117 3.2101 0 1.6285 4.3651 2.8615 0 3.5131 3.6602 4.0027 0.2540 1.4389 4.2407 3.8797 0.0071

0.6817 0.9596 1.9496 1.0765 1.0230 0 0.8627 1.0861 0.9233 0 1.1503 1.2760 0.6853 0.4280 0.6985 1.5162 0.5979 0.0092

2.5268 1.0359 3.1935 3.2420 3.5833 0 4.8789 4.8389 3.8968 0.4922 3.3708 4.2677 4.6955 0.4009 2.2341 4.4753 4.3816 0.3124

0.6103 0.7847 1.9555 1.5935 1.4719 0 2.2005 1.1356 1.0317 1.0466 0.6058 1.0064 1.1338 0.8861 0.9059 1.5330 0.9752 0.2444

70×10 70×15 70×20 100×5 100×10 100×15 100×20 Mean

0.1894 0.6636 0.8432 0.0098 0.0491 0.2708 0.3063 0.2283

0.3993 0.3157 0.4302 0.0207 0.0451 0.1904 0.1857 0.1734

0.1241 2.3610 2.6849 0.0295 0.7086 0.6499 2.2952 1.2019

0.2956 0.7825 0.5703 0.0254 0.4317 0.2261 0.4973 0.4116

0.1829 1.5227 1.6080 0 0.5870 0.9432 1.9368 1.0292

0.2950 0.5898 0.5662 0 0.3402 0.5641 0.3295 0.4589

0.6793 3.8756 3.7396 0.0344 1.5552 2.8726 2.9285 2.1402

0.4644 0.7298 0.9586 0.0238 0.5477 0.4808 0.7316 0.7624

1.6313 4.2988 4.0207 0.0246 1.3026 3.1400 3.2164 2.6853

1.0843 0.9136 0.7745 0.0259 0.4423 0.5703 0.7450 0.9505

Int J Adv Manuf Technol

4 Brief introduction to the basic SFLA SFLA is a new meta-heuristic proposed by Eusuff et al. [23] for solving problems with discrete decision variables. Inspired by natural memetics, SFLA is a population-based cooperative search metaphor combining the benefits of the genetic-based memetic algorithm and the social behaviorbased particle swarm optimization. In SFLA, a population of randomly generated P solutions forms an initial population X ¼ fxð1Þ; xð2Þ; :::; xðPÞg, where each solution x(i) called a frog is represented by an n-dimensional vector xðiÞ ¼ fx1 ðiÞ; x2 ðiÞ; :::; xn ðiÞg. SFLA starts with the whole population partitioned into a number of parallel subsets referred to as memeplexes. Then each memeplex is considered as a different culture of frogs and permitted to evolve independently to search the space. Within each memeplex, the individual frogs hold their own ideas, which can be affected by the ideas of other frogs, and experience a memetic evolution. During the evolution, the frogs may change their memes by using the information from the memeplex best x(b) or the best individual of entire population x(g). Incremental changes in memotypes correspond to a leaping step size and the new meme corresponds to the frog’s new position. In each cycle, only the frog with the worst fitness x(w) in the current memeplex is improved by a process similar to PSO as follows. 8 minfint½randðÞðxðbÞ  xðwÞ; LSmax Þg > > > < for a positive step LS ¼ : > maxfint½randðÞ  ðxðbÞ  xðwÞ; LSmax Þg > > : for a negitive step

ð24Þ

where rand() is a random number between 0 and 1, LSmax is the maximum step size allowed to be adopted by a frog after being infected, and LS is the n-dimensional leaping size vector. A frog with new position is then produced by U ¼ xðwÞ þ LS

ð25Þ

Finally, a selection operator is applied to the frogs U and x(w) as follows.  xðwÞ ¼

U xðwÞ

if U is better than xðwÞ otherwise

If x(w) is not improved in the above process, the Eqs. 24 through 26 are repeated by using x(g) to replace x(b). If no improvement becomes possible in this case, then x(w) is replaced by a randomly generated solution within the entire feasible space. After a predefined number of memetic evolution steps, the frogs in memeplexes are submitted to a shuffling process, where all the memeplexes are combined into a whole population and then the population is again divided into several new memeplexes. The memetic local search and shuffling process are repeated until a given termination condition is reached. The pseudo code for the basic SFLA is summarized as follows [23].

Begin Generate a population of P frogs randomly; While not terminated, do Calculate fitness for each frog; Divide the population into several memeplexes; For each memeplex, repeat the following steps for a number of iterations Determine the best and worst frogs; Improve the worst frog position x(w) using Eqs (24) through (26); If no improvement becomes possible in this case, then x(w) is replaced by a randomly generated solution within the entire feasible space. End for; Combine the evolved memeplexes; End while; End.

ð26Þ

Int J Adv Manuf Technol

In this section, we will present an effective SFLA for solving the lot-streaming flow shop scheduling problem with makespan criterion after explaining solution representation, population initialization, partitioning scheme, memetic evolution process, shuffling process, and a local search. 5.1 Solution representation and population initialization One of the key issues when designing SFLA lies in its solution representation where frogs or individuals bear the necessary information related to the problem domain on hand. The job permutation-based representation is easy to decode a schedule, which has been widely used in literature for a variety of permutation flow shop scheduling problems. For this reason, it is also used in the proposed SFLA. The Nawaz–Enscore–Ham (NEH) heuristic [31] is one of the well-known heuristics in the literature, and it provides good performance for permutation flow shop scheduling problems. To guarantee an initial population with a certain quality and diversity, we take advantage of NEH to produce an individual or frog, whereas the others are randomly generated. The NEH heuristic has two phases. In phase I, an initial permutation : ={: 1, : 2,...,: n} is generated by sorting jobs in descending sums of their total processing times. In phase II, a job permutation is established by evaluating the partial sequences based on the initial of phase I. Suppose a current sequence 0 order 0 0 p 0 ¼ p 1 ; p 2 ; :::; p i is already determined for the first i jobs of the initial permutation : , then i+1 partial sequences are constructed by inserting job : i+1 into the i+1 possible slots of the current sequence. Among these i+1 partial sequences, the one with the minimum makespan is kept as the current sequence for the next iteration. The phase II is repeated by considering job πi+2 and so on until all the jobs have been scheduled. Obviously, there are (n−1)(n+2)/2 partial sequences generated in the phase II, and the speedup method proposed in Section 3 can be used to evaluate the partial schedules, so the NEH heuristic can be executed in time O(mn2) for the lot-streaming flow shop scheduling problem in both the no-idling and idling cases. 5.2 Partition the population into memeplexes In SFLA, the entire population of virtual frogs is partitioned into a number of memeplexes. Each memeplex is an independent evolution unit and performs a memetic search in its own solution space. To construct these memeplexes, the frogs are first sorted in a descending order according to their performance values. Then the population is divided based on the order yielded. Suppose that there are Pn

subsets and each subset has Pm frogs (note that P=Pm× Pn). The first frog enters memeplex 1, the second frog enters memeplex 2, the Pnth frog enters memeplex Pn, the (Pn+1)th frog goes back to memeplex 1, and so on until all the frogs are considered. 5.3 Memetic evolution in each memeplex Within each memeplex, the virtual frogs experience an independent evolution process to improve the quality of their memes and enhance their performance toward global optima [23]. However, the evolution method presented in the basic SFLA is not suitable for the lot-streaming flow shop scheduling problem considered in this paper, since the standard position updating formula cannot be used to produce a feasible individual represented by a job permutation. Therefore, we propose a novel method to generate a new frog position as follows. U ¼ f ðxðwÞ; pðxÞÞ

ð27Þ

where x(w) is the worst individual in the current memeplex, p(w) is the memeplex best x(b) or entire population best x (g), and the function f() is a position based crossover operator presented by Murata et al. [32]. This crossover operator generates a child individual U from two parent individuals x(w) and p(x) as follows. Two jobs randomly selected in x(w) are inherited to the child U, and the other jobs are placed in the order of their appearance in p(x). Suppose that x(w)={1,6,3,5,2,4}, p(x)= {3,1,5,4,2,6}, and the selected jobs are 6 and 2 in x(w).

x 104

1.1

SFLA

1.08

HAG

1.06

ACO TAinsert TAswap

1.04

Makespan

5 The proposed SFLA for lot-streaming flow shop problem

1.02 1

0.98 0.96 0.94 0.92 0.9

0

10

20

30

40

50

60

70

80

90

100

CPU Time

Fig 9 Typical convergence graphics for problem 100×20 under noidling case

Int J Adv Manuf Technol

Then offspring permutation is U={3,6,1,5,2,4} (see the example in Fig. 8). In the basic SFLA, a new frog will be generated randomly in the predefined search scope if an individual with better fitness than x(w) cannot be produced by using the information from x(b) or x(g), and then the generated frog will replace x(w) and become a new member in the current memeplex. This will decrease the search efficacy. Since the memeplex best x(b) or the best individual of the entire population x(g) often carries better information than others during the evolution process, the search space around it could be the most promising region. Therefore, in the proposed SFLA, the new frog is generated by performing several “insert” operators to x(b) or x(g), and to avoid the algorithm trap into a local optimum, at least three “insert” operators are performed.

5.4 Shuffling of population After the memetic evolution process in the memeplexes, a shuffling procedure is continued. To enhance the quality of memes being infected by frogs from different regions of the swamp, all the frogs in the different memeplexes are combined together into an entire population. Then SFLA will repeat its search based on the combined population. Furthermore, the population best frog x(g) will be updated. 5.5 Local search In order to enhance the exploitation capability of the proposed SFLA, a problem-dependent local search algorithm is presented and applied to the best frog or individual updated in the entire population after the shuffling process.

Table 2 Comparison of SFLA with and without local search under no-idling case n×m

SFLA

NEH

SFLSnoLs

ARPI

SD

ARPI

SD

ARPI

10×5 10×10 10×15 10×20 20×5

0 0 0 0 0

0 0 0 0 0

0.1658 0 0 0.0803 0.6247

0.3097 0 0 0.1293 0.0000

2.1762 0.8019 3.3031 2.9979 0.6247

20×10 20×15 20×20 30×5 30×10 30×15 30×20 40×5 40×10 40×15 40×20 50×5 50×10 50×15 50×20 70×5 70×10 70×15

0.0691 0.2739 0.0870 0 0 0.5875 0.2914 0 0.3341 0.4764 0.2943 0.0199 0.4851 0.5366 0.6055 0 0.1894 0.6636

0.1884 0.2204 0.1431 0 0 0.3580 0.2438 0 0.2903 0.2586 0.1939 0.0420 0.6262 0.3645 0.3375 0 0.3993 0.3157

0.8157 1.4660 1.1232 0 0.5720 2.5995 2.1399 0 2.4370 2.4653 2.7122 0.1170 1.2127 3.2631 3.2065 0 0.9471 3.3563

0.0689 0.2158 0.1220 0 0.1166 0.4783 0.5558 0 0.7739 0.3078 0.2197 0.0312 0.0000 0.3758 0.4280 0 0.0000 0.3896

3.2719 2.8997 1.7391 0 4.2396 4.3272 3.1918 0 4.0252 3.4283 3.4412 0.7719 1.4692 4.1277 5.4172 0 1.1920 4.3597

70×20 100×5 100×10 100×15 100×20 Mean

0.8432 0.0098 0.0491 0.2708 0.3063 0.2283

0.4302 0.0207 0.0451 0.1904 0.1857 0.1734

3.1479 0.0394 0.3145 1.9429 2.5950 1.3337

0.2985 0.0207 0.0800 0.3215 0.1756 0.1935

4.5118 0.0492 1.0407 2.6853 3.2587 2.4768

Int J Adv Manuf Technol

For the job permutation-based optimization problems, “insert,” “swap,” and “inverse” operators are commonly used to produce a neighboring solution [29]. Among them, “insert” operator is the most suitable for performing a fine local search [33]. Thus, we employ “insert” operator to be embedded in SLFA to refine local search for the problem considered. Let : ={: 1, : 2,...,: n} be the best job permub tation updated   in the entire population and p ¼ b b b p 1 ; p 2 ; :::; p n denote the best job sequence found so far. The local search algorithm is described as follows. Step 1. Set i=1. Step 2. Find job p bi in permutation π and remove it. Step 3. Insert job p bi in another different position of the permutation : and adjust the permutation accordingly by not changing the relative positions of the other jobs. Consider all the possible insertion

positions and denote the best one among the obtained sequences : *. If : * is better than π, then let : = : *. Note that in this step, the speed-up method presented in Section 3 can be applied to save computational time. Step 4. Let i=i+1. If i≤n, then go to step 2. Step 5. If the permutation π was improved in the above steps 1 through 4, then go to step 1; otherwise, output the current permutation : . The above local search algorithm is effective and efficient due to the following reasons. Firstly, the local search is performed to the best individual updated in the entire population to avoid both cycling search and getting entrapped in a non-global local optimum. Secondly, in the local search, the incumbent solution is updated only when a better solution is found so as to rapidly reach a local

Table 3 Comparison of different algorithms under idling case n×m

SFLA

HGA

ACO

TAswap

TAinsert

ARPI

SD

ARPI

SD

ARPI

SD

ARPI

SD

ARPI

SD

10×5 10×10 10×15

0 0 0

0 0 0

0 0.3165 0.1914

0 0.4325 0.0672

0.7060 0.4705 0.3331

1.0444 1.1053 0.5377

1.2856 1.7023 2.0695

1.1552 1.1849 1.2977

2.7081 1.9076 1.7364

0.8298 1.4218 1.4375

10×20 20×5 20×10 20×15 20×20 30×5 30×10 30×15 30×20 40×5 40×10 40×15 40×20 50×5 50×10 50×15 50×20 70×5

0 0 0.3420 0.3083 0.3222 0 0 0.6515 0.3964 0 0.4361 0.4958 0.3741 0.0100 0 0.5080 0.2762 0

0 0 0.4511 0.2585 0.3261 0 0 0.4161 0.2603 0 0.2679 0.3808 0.2739 0.0316 0 0.2426 0.2358 0

0.2404 0.5870 2.2613 1.7708 2.0445 0.0490 0.3686 2.4700 2.2396 0.1218 2.4538 2.7382 2.6509 0.1123 0.7235 3.0367 2.0198 0.0071

0.4236 0.9451 0.8499 0.4300 1.2259 0.1032 0.4088 0.5286 0.4355 0.1049 0.4906 1.0046 0.7406 0.0358 0.7951 0.7792 0.7447 0.0172

0.4934 1.3221 2.0475 1.4417 0.9053 0 0.2841 2.1297 1.4005 0.0406 2.0287 2.0935 1.6755 0.0923 0.2975 2.1930 1.0764 0

0.3885 0.9241 0.7358 0.5051 0.6615 0 0.1960 0.6233 0.5106 0.0856 0.7387 0.6573 0.4295 0.0334 0.2610 0.9545 0.6123 0

1.8975 2.3109 4.0143 2.2833 3.1530 0.1959 1.1397 4.7131 3.0179 0.1218 4.3886 4.9679 3.9178 0.1771 2.0514 4.1762 3.4328 0.0551

1.2685 1.6489 1.9141 0.8720 1.3434 0.1032 1.1686 1.0997 0.5401 0.1049 1.4771 1.2953 1.3414 0.1119 0.9617 1.1788 1.0842 0.1434

2.7894 2.2581 3.4394 3.3333 3.7476 0.1294 1.9716 4.2496 3.9091 0.2959 3.5661 4.6802 3.4450 0.2670 2.5440 4.4898 3.4086 0.1581

0.8762 1.2721 1.4203 0.8075 0.9573 0.1902 0.9882 1.5422 0.8565 0.5877 1.0271 1.2215 1.0263 0.1205 1.1052 1.1083 1.2242 0.2008

70×10 70×15 70×20 100×5 100×10 100×15 100×20 Mean

0 0.3432 0.6110 0 0.0421 0.2472 0.2824 0.2017

0 0.2497 0.3194 0 0.0176 0.2833 0.1856 0.1500

0.0960 2.9011 2.3839 0.0037 1.2267 2.6088 3.6868 1.4039

0.2060 0.6388 0.6544 0.0117 0.2590 0.2775 0.4138 0.4651

0 2.5465 1.4720 0 0.8264 1.9868 2.7604 1.0937

0 0.4667 0.3317 0 0.2743 0.3969 0.4422 0.4613

0.7462 4.1298 3.3333 0.0505 1.1764 2.8628 3.9286 2.4036

0.5360 0.7068 0.8237 0.1095 0.6493 0.6241 1.0329 0.9206

1.1218 4.1347 3.4801 0.0530 0.8709 2.9050 3.2527 2.5304

1.0137 0.8631 0.9774 0.0824 0.3449 0.7145 0.3193 0.8763

Int J Adv Manuf Technol

solution. Lastly, by using the speed-up method proposed in Section 3, the insert neighbors can be evaluated efficiently. Thus, the local search algorithm tends to enhance the local exploitation of the SFLA algorithm in a relatively short time. 5.6 Computational procedure of the proposed SFLA With the components implemented above for SFLA, its computational procedure is outlined as follows: Step 1 Set the algorithm parameters P and Pm, where P is the entire population size, and Pm is the number of memeplexes. Step 2 Initialize the population and evaluate each frog in the population. Step 3 Partition frogs into Pm memeplexes, and record the best individual as x(g). Step 4 For each memeplex, repeat the following sub-steps: Step 4.1 Determine the best frog x(b) and the worst one x(w). Step 4.2 Generate an individual U by using the crossover operator on x(b) and x(w). If U is better than x(w), go to step 4.5. Step 4.3 Generate an individual U by using the crossover operator on x(g) and x(w). If U is better than x(w), go to step 4.5. Step 4.4 Generate an individual U by performing “insert” operators to x(b) or x(g), where x(b) and x(g) are selected randomly. Step 4.5 Replace x(w) by the generated individual U. Step 5 Perform the shuffling process and combine the Pm memeplexes into an entire population. Step 6 Perform the local search to the best individual updated in the entire population. Step 7 If the termination criterion is reached, return the best solution found so far; otherwise, go to step 3.

problem involved setup time with equal-size sublots under both the no-idling and idling cases, a series of computational experiments and comparisons between SFLA and the best performing algorithms from the literature are conducted in this section. There are several existing meta-heuristics for solving the lot-streaming flow shop scheduling problem considered. Typically, Marimuthu, Ponnambalam, and Jawahar [1] presented a GA and a HGA, where HGA adopts the framework of the proposed GA plus local search between mutation and new population generation modules. It was concluded by the authors that both the proposed GA and HGA are capable of producing optimal solutions and the HGA performs much better than the GA in terms of solution quality. Recently, Marimuthu, Ponnambalam, and Jawahar [2] further proposed a TA and ACO algorithms, and the computational experiments and comparisons revealed that both the TA and ACO algorithms are effective and efficient for solving the lot-streaming flow shop scheduling problem. Therefore, in this section, the proposed SFLA is compared with the HGA, TA, and ACO algorithms. In the experiments, 28 problems with different sizes n×m, where n=10, 20, 30, 40, 50, 70, 100 and m=5, 10, 15, 20, are randomly generated. Related data are given by discrete uniform distributions as follows: l(j)∈U [1, 6], p(i, j)∈U [1, 31], and s(i, j)∈U [1, 31]). All the compared algorithms are coded in Visual C++ and executed on a Pentium PIV 3.0 GHz PC with 512 MB memory. The parameters for the proposed SFLA are set as P=20 and Pn=4. On the other hand, for the best performing algorithms from the literature, the parameters are fixed at the same as those given in literature. To make a fair comparison, all the algorithms adopt the same maximum CPU time limit of t=50mnms as a termination criterion. For each instance, ten x 104

1.1

SFLA

1.08

HAG

1.06

ACO TAinsert TAswap

1.04

Makespan

It can be seen from the above procedure that the proposed SFLA not only performs an independent evolution within each memeplexes, but also periodically exchanges information among the memeplexes by a shuffling process and partitioning procedure to ensure global exploration. In addition, an effective local search method is embedded to further stress the exploitation ability. Since exploration and exploitation are balanced and efficiency of solution evaluation are stressed, it is expected to achieve good results for the lot-streaming flow shop scheduling problems with makespan criterion in both idling and no-idling cases.

1.02 1 0.98 0.96 0.94 0.92 0.9

6 Computational results and comparisons To test the performance of the proposed SFLA to minimize makespan for the lot-streaming flow shop scheduling

0

10

20

30

40

50

60

70

80

90

100

CPU Time

Fig 10 Typical convergence graphics for problem 100×20 under idling case

Int J Adv Manuf Technol

independent replications are carried out, and for each replication, the relative percentage increase (RPI) is calculated as follows:   » » RPIðci Þ ¼ ci  c =c  100 ð28Þ where ci is the objective value generated in the ith replication by an algorithm and c* is the best objective value found by any of the algorithms compared. Obviously, the smaller the RPI value, the better result the algorithm produces. In addition, the average relative percentage increase (ARPI) and standard deviation (SD) over the ten replications are also calculated as statistics for the solution quality. 6.1 Comparison under no-idling case The algorithms defined above were originally designed for the lot-streaming flow shop scheduling under the idling

case, that is, idling production interruption times between any two adjacent sublots of a job are allowed. To apply them to the lot-streaming flow shop scheduling under the no-idling case, their objective function evaluation method is modified by considering no-idling production interruption time between any two adjacent sublots of a job at the same stage. Table 1 reports the computational results. In the table, “TA insert ” means that the “insert” neighborhood is employed in the TA algorithm, whereas “TAswap” implies that the “swap” neighborhood is adopted. It can be easily seen from Table 1 that the proposed SFLA is the winner in terms of the overall solution quality, since it yields the smallest overall mean ARPI value equal to 0.2283% and the smallest overall mean SD value equal to 0.1734%, which are much smaller than those by the HGA (1.2019%/0.4116%), ACO (1.0292%/0.4589%), TA insert (2.1402%/0.7624%), and TA swap (2.6853%/

Table 4 Comparison of SFLA with and without local search under idling case n×m

SFLA

NEH

SFLSnoLs

ARPI

SD

ARPI

SD

ARPI

10×5 10×10 10×15

0 0 0

0 0 0

0 0.0171 0.2126

0 0.0361 0

1.8967 1.4542 0.2126

10×20 20×5 20×10 20×15 20×20 30×5 30×10 30×15 30×20 40×5 40×10 40×15 40×20 50×5 50×10 50×15 50×20 70×5

0 0 0.3420 0.3083 0.2837 0 0 0.6515 0.3964 0 0.4361 0.4958 0.3741 0.0100 0 0.5080 0.2156 0

0 0 0.4511 0.2585 0.3260 0 0 0.4161 0.2603 0 0.2679 0.3808 0.2739 0.0316 0 0.2426 0.2357 0

0.6072 0 2.6698 2.3792 1.3842 0 0.3585 3.0243 2.4913 0.2031 2.0729 3.0131 2.5935 0.0798 1.6468 3.0080 1.8554 0.0089

0.5226 0 0.4289 0.1784 0.3408 0 0.2557 0.5340 0.5359 0.0000 0.6073 1.0549 0.2280 0.0421 0.5581 0.6514 0.1311 0.0151

2.7198 1.7451 5.4632 5.7500 3.7193 0 1.1836 6.5154 4.3981 0.2031 4.4162 5.2659 3.1214 0.0998 4.4503 3.9090 2.4577 0.0355

70×10 70×15 70×20 100×5 100×10 100×15 100×20 Mean

0 0.3432 0.6110 0 0.0421 0.2472 0.2824 0.1981

0 0.2497 0.3194 0 0.0176 0.2833 0.1856 0.1500

0 2.6777 2.9320 0 0.7960 1.2839 1.1890 1.3037

0 0.3081 0.5241 0 0.1529 0.0402 0.2263 0.2633

0.2482 3.5940 3.3992 0 1.0886 1.6632 1.8681 2.5314

Int J Adv Manuf Technol

0.9505%) algorithms. Moreover, SFLA achieves the best ARPI values for all the 28 problems except the one with size 70×10, and for nine problems, SFLA outputs the best objective value in each of the ten replications. When comparing with the ACO algorithm, SFLA produces better results for 23 out of all the 28 problem sizes and worse results for only two problem sizes. When compared to the HGA, TAswap, and TAinsert algorithms, SFLA finds 24, 26, and 27 better results, respectively. Especially, none of the results generated by SFLA is worse than that by any of the TAswap and TAinsert algorithms. In addition, typical convergence graphics of the compared algorithms for solving problem 100×20 (illustrated in Fig. 9) show that the proposed SFLA converges much faster to reach lower levels than other compared algorithms. Hence, it is concluded that overall, the proposed SFLA is superior to the ACO, HGA, TAswap, and TAinsert algorithms for solving the lot-streaming flow shop scheduling problem with the makespan criterion at the noidling case under the same computational time. Next, we compare the proposed SFLA with and without local search. For simplicity, denote them as SFLA and SFLAnoLS, respectively. The computational results are summarized in Table 2. It can be observed that the results for 23 out of 28 problems generated by SFLAnoLS are improved by SFLA, which demonstrates the effectiveness of incorporating a local search into the SFLA variant. In other words, the superiority in terms of search ability and efficiency of the proposed SFLA should be attributed to the combination of global search and local search with an appropriate balance between exploration and exploitation. The effectiveness of the SFLA algorithm against the NEH heuristic is also reported in Table 2. It can be seen that the overall mean ARPI value yielded by the SFLA algorithm is much better than those by the NEH heuristic. 6.2 Comparison under idling case In this section, the proposed SFLA is compared with the HGA, TA, and ACO algorithms for the lot-streaming flow shop scheduling problem under the idling case, and the computational results are summarized in Table 3, and typical convergence graphics for problem 100×20 are plotted in Fig. 10. It is clear from the table and figure that the proposed SFLA outperforms the other compared algorithms at the same computational time. Finally, the computational results produced by SFLA with and without local search in Table 4 further suggest that the superiority in terms of search ability and efficiency of SFLA should be attributed to the combination of global search and local search with an appropriate balance between exploration and exploitation. All in all, it can be concluded that the proposed SFLA performs much better than the existing HGA, TA, and ACO

algorithms at the same computational time to minimize makespan for the lot-streaming flow shop scheduling problems with equal-size sublots under both the idling and no-idling cases.

7 Conclusions This paper aimed at minimizing makespan for the flow shop scheduling problem under lot-streaming environment with equal-size sublots. We proposed a novel SFLA and considered the problem under both the idling and no-idling production cases. To the best of our knowledge, this was the first reported application of SFLA for solving the problem under consideration. With the representation based on discrete job permutations, the SFLA-based searching mechanism was presented to find promising solutions in the entire search space by using an effective population initialization approach and a novel candidate generation strategy. In addition, a simple but effective local search algorithm was designed to further enhance the exploitation capability, and a speed-up method was presented to improve the search efficiency. Due to the reasonable hybridization of SFLA search and local search as well as the utilization of the speed-up approach, the proposed SFLA was of the ability to obtain good results for the lotstreaming flow shop scheduling problems with makespan criterion. Computational simulations and comparisons demonstrated the effectiveness of the proposed SFLA over some existing algorithms. The future work is to develop other meta-heuristics for the lot-streaming flow shop problem and to generalize the application of the proposed SFLA for other combinatorial optimization problems. Acknowledgments This research is partially supported by National Science Foundation of China (60874075, 70871065, 60834004, 60774082), National 863 Hi-Tech RandD Plan (2007AA04Z155), and Open Research Foundation from State Key Laboratory of Digital Manufacturing Equipment and Technology (Huazhong University of Science and Technology) and Postdoctoral Science Foundation of China (20070410791).

References 1. Marimuthu S, Ponnambalam SG, Jawahar N (2008) Evolutionary algorithms for scheduling m-machine flow shop with lot streaming. Robot Comput Integr Manuf 24:125–139 2. Marimuthu S, Ponnambalam SG, Jawahar N (2009) Threshold accepting and ant-colony optimization algorithm for scheduling m-machine flow shop with lot streaming. J Mater Process Technol 209:1026–1041 3. Yoon SH, Ventura JA (2002) An application of genetic algorithms to lot-streaming flow shop scheduling. IIE Trans 34:779–787 4. Chang JH, Chiu HN (2005) A comprehensive review of lot streaming. Int J Prod Res 43:1515–1536

Int J Adv Manuf Technol 5. Tseng CT, Liao CJ (2008) A discrete particle swarm optimization for lot-streaming flowshop scheduling problem. Eur J Oper Res 191:360–373 6. Baker KR, Jia D (1993) A comparative study of lot streaming procedure. Omega 21:561–566 7. Trietsch D, Baker KR (1993) Basic techniques for lot streaming. Oper Res 41:1065–1076 8. Kropp DH, Smunt TL (1990) Optimal and heuristic models for lot splitting in a flow shop. Decis Sci 21:691–709 9. Bukchin J, Tzur M, Jaffer M (2002) Lot splitting to minimize average flow-time in a two-machine flow-shop. IIE Trans 34:953– 970 10. Liu J (2008) Single-job lot streaming in m−1 two-stage hybrid flowshops. Eur J Oper Res 187(3):1171–1183 11. Edis RS, Ornek MA (2009) A tabu search-based heuristic for single-product lot streaming problems in flow shops. Int J Adv Manuf Technol 43:1202–1213 12. Vickson RG, Alfredsson BE (1992) Two- and three-machine flow shop scheduling problems with equal size transfer batches. Int J Prod Res 30:1551–1574 13. Cetinkaya FC (1994) Lot streaming in a two-stage flow shop with set-up, processing and removal times separated. J Oper Res Soc 45:1445–1455 14. Vickson RG (1995) Optimal lot streaming for multiple products in a two-machine flow shop. Eur J Oper Res 85:556–575 15. Sriskandarajah C, Wagneur E (1999) Lot streaming and scheduling multiple products in two-machine no-wait flowshops. IIE Trans 31:695–707 16. Kumar S, Bagchi TP, Sriskandarajah C (2000) Lot streaming and scheduling heuristics for m-machine no-wait flowshops. Comput Ind Eng 38:149–172 17. Kalir AA, Sarin SC (2001) A near-optimal heuristic for the sequencing problem in multiple-batch flow-shops with small equal sublots. Omega 29:577–584 18. Yoon SH, Ventura JA (2002) Minimizing the mean weighted absolute deviation from due dates in lot-streaming flow shop scheduling. Comput Oper Res 29:1301–1315 19. Marimuthu S, Ponnambalam SG (2005) Heuristic search algorithms for lot streaming in a two-machine flowshop. Int J Adv Manuf Technol 27:174–180

20. Martin CH (2009) A hybrid genetic algorithm/mathematical programming approach to the multi-family flowshop scheduling problem with lot streaming. Omega 37:126–137 21. Wang L (2003) Shop scheduling with genetic algorithms. Tsinghua University Press, Beijing 22. Elbeltagi E, Hegazy T, Grierson D (2005) Comparison among five evolutionary-based optimization algorithms. Adv Eng Inform 19:43–53 23. Eusuff MM, Lansey KE (2003) Optimization of water distribution network design using the shuffled frog leaping algorithm. J Water Resourc Plan Manage 129:210–225 24. Eusuff M, Lansey K, Pasha F (2006) Shuffled frog-leaping algorithm: a memetic meta-heuristic for discrete optimization. Eng Optim 38:129–154 25. Rahimi-Vahed A, Mirzaei AH (2008) Solving a bi-criteria permutation flow-shop problem using shuffled frog-leaping algorithm. Soft Comput 12:435–452 26. Chung G, Lansey KE (2009) Application of the shuffled frog leaping algorithm for the optimization of a general large-scale water supply system. J Water Resourc Manage 23:797–823 27. Rahimi-Vahed A, Mirzaei AH (2007) A hybrid multi-objective shuffled frog-leaping algorithm for a mixed-model assembly line sequencing problem. Comput Ind Eng 53:642–666 28. Rahimi-Vahed A, Dangchi M, Rafiei H, Salimi E (2009) A novel hybrid multi-objective shuffled frog-leaping algorithm for a bicriteria permutation flow shop scheduling problem. Int J Adv Manuf Technol 41:1227–1239 29. Grabowski J, Pempera J (2005) Some local search algorithms for no-wait flow-shop problem with makespan criterion. Comput Oper Res 32:2197–2212 30. Taillard E (1990) Some efficient heuristic methods for the flow shop sequencing problems. Eur J Oper Res 47:65–74 31. Nawaz M, Enscore EEJ, Ham I (1983) A heuristic algorithm for the m-machine, n-job flow shop sequencing problem. Omega 11:91–95 32. Murata T, Ishibuchi H, Tanaka H (1996) Genetic algorithms for flow shop scheduling problems. Comput Ind Eng 30:1061–1071 33. Qian B, Wang L, Huang DX, Wang WL, Wang X (2009) An effective hybrid DE-based algorithm for multi-objective flow shop scheduling with limited buffers. Comput Oper Res 36:209–233