Effects of different chromosome representations in developing genetic algorithms to solve DFJS scheduling problems

Computers and Operations Research 80 (2017) 101–112

Contents lists available at ScienceDirect

Computers and Operations Research journal homepage: www.elsevier.com/locate/cor

Effects of different chromosome representations in developing genetic algorithms to solve DFJS scheduling problems Muh-Cherng Wu∗, Chi-Shiuan Lin, Chia-Hui Lin, Chen-Fu Chen Department of Industrial Engineering and Management, National Chiao Tung University, Hsin-Chu City 30010, Taiwan

a r t i c l e

i n f o

Article history: Received 16 December 2015 Revised 21 November 2016 Accepted 21 November 2016 Available online 22 November 2016 Keywords: Scheduling Distributed flexible job shop Genetic algorithm Chromosome representation

a b s t r a c t This paper attempts to compare the effect of using different chromosome representations while developing a genetic algorithm to solve a scheduling problem called DFJS (distributed flexible job shop scheduling) problem. The DFJS problem is strongly NP-hard; most recent prior studies develop various genetic algorithms (GAs) to solve the problems. These prior GAs are similar in the algorithmic flows, but are different in proposing different chromosome representations. Extending from this line, this research proposes a new chromosome representation (called SOP ) and develops a genetic algorithm (called GA_OP) to solve the DFJS problem. Experiment results indicate that GA_OP outperforms all prior genetic algorithms. This research advocates the importance of developing appropriate chromosome representations while applying genetic algorithms (or other meta-heuristic algorithms) to solve a space search problem, in particular when the solution space is high-dimensional. © 2016 Elsevier Ltd. All rights reserved.

1. Introduction This paper attempts to compare the effect of using different chromosome representations while developing a genetic algorithm to solve a scheduling problem called DFJS (distributed flexible job shop scheduling) problem. A chromosome representation denotes the solution representation scheme used in a genetic algorithm. A genetic algorithm (GA) is designed to search the solution space by an evolutionary approach (Bäck and Schwefel) [1], in which various solutions are constantly generated and good ones are selected to generate new solutions. The generate-and-select process iteratively proceeds; the best solution found in the iterative process is the obtained solution. A DFJS scheduling problem addresses a factory which involves multiple manufacturing cells. Each manufacturing cell (simply called cell) involves many machines and is independently operated. In a DFJS problem, a set of jobs are to be scheduled on these cells and machines; a job shall be completely processed in a particular cell (i.e., cross-cell production is prohibited). Therefore, a DFJS problem involves three decisions: (1) job-to-cell assignment, (2) operation-to-machine assignment, and (3) operation sequencing decision. A chromosome that can be used to obtain each of the above three DFJS decisions can yield a unique scheduling solution.

∗

Corresponding author. Fax: +886 3 5729 101. E-mail addresses: [email protected] [email protected] (C.-S. Lin). http://dx.doi.org/10.1016/j.cor.2016.11.021 0305-0548/© 2016 Elsevier Ltd. All rights reserved.

(M.-C.

Wu),

The DFJS problem is strongly NP-hard; most prior studies developed various GAs to solve the DFJS problems. These prior GA studies are similar in the algorithmic flows but are distinguished in proposing different chromosome representations. In this paper, these prior GAs and their chromosome representations are denoted as follows. Chan et al. [5] developed an algorithm (called GADG), in which the chromosome representation (called SCH ) can explicitly model each of the three DFJS decisions. Using a different approach, Chang and Liu [8] developed an algorithm (called GA_CL), in which the chromosome representation (called SCL ) can also explicitly model each of the three DFJS decisions. Giovanni and Pezzella [11] developed an algorithm (called IGA), in which the chromosome representation (called SGP ) models only two DFJS decisions and the remaining one decision is determined by applying a heuristic rule. Lu et al. [30] developed an algorithm (called GA_ JS), in which the chromosome representation (called SJS ) models a DFJS solution only by a job sequence and the three DFJS decisions are determined by three heuristic rules. The prior studies on solving DFJS problems made the following claims: IGA outperforms GADG; in addition, both GA_ JS and GA_CL outperform IGA. Yet, these claims are based on different DFJS problem instances. To make a fair comparison, we take IGA, GA_CL, and GA_ JS as the three benchmarks for evaluating our proposed genetic algorithm (called GA_OP). The proposed genetic algorithm GA_OP is designed to solve the DFJS problem, in which a new chromosome representation (called SOP ) is developed. Of the three DFJS decisions, the chromosome SOP explicitly models the operation sequence decision and the re-

102

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

maining two DFJS decisions are determined by applying heuristic rules, which are designed toward achieving a load-balance among cells as well as a load-balance among machines. The proposed algorithm GA_OP is empirically compared against the three benchmark algorithms (IGA, GA_CL, and GA_ JS). Numerical experiment results indicate that GA_OP outperforms the three benchmarks. The remaining of this paper is organized as follows. Section 2 reviews relevant literature. Section 3 describes the DFJS problems. Section 4 compares the proposed SOP chromosome representation against the four prior ones (SCH , SCL , SGP , and SJS ). Section 5 presents the decoding method which converts the proposed SOP chromosome representation into a DFJS scheduling solution. Section 6 presents the algorithmic flow of the proposed GA_OP. Section 7 reveals the experiment results and concluding remarks are in Section 8.

2. Relevant literature As stated, a DFJS problem is concerned with the scheduling of n jobs in multiple manufacturing cells and each cell is a flexible job shop. A DFJS problem can be degenerated to three scheduling problems (JS, DJS, and FJS). A JS problem (job shop scheduling) involves only one cell and each job has only one route. A DJS problem (distributed job shop scheduling) involves multiple cells and each job has only one route. A FJS problem (flexible job shop scheduling) involves only one cell and each job has multiple routes. In contrast, a DFJS problem involves multiple cells and each job has multiple routes. A JS problem is a well-known NP-hard problem [17]. Jones et al. [25] surveyed various techniques for solving JS problems. Due to its inherent intractability, many meta-heuristic algorithms (e.g., GA, simulated annealing, tabu search) have been developed to solve the JS problems. Cheng et al. [9] presented a survey on various chromosome representations used in developing GAs to solve the JS problems. They further gave a survey on the GAs which developed various hybrid genetic search strategies in solving the JS problems [10]. Typical studies on JS problems aimed to minimize makespan, some others aim to minimize other single objective [27] or multiple objectives [34]. In solving DJS problems, there are relatively few prior studies. Jia et al. [21–23] have proposed various GAs. Naderi and Azab [32] developed two mixed integer linear programming models to solve small-sized DJS problems; and develop three heuristics to solve large sized problems. They further developed a new encoding scheme and proposed a simulated annealing algorithm [33]. In solving FJS problems, there are relatively more prior studies. The first study on FJS problems is by Brucker and Schlie [4], in which a polynomial algorithm is proposed for solving FJS problems with two jobs. Genova et al. [18] recently presented a survey of solution approaches in solving FJS problems that aim to optimize multiple objectives. Considering either multiple-objectives or single-objective, the FJS solution approaches can be categorized into two groups. The first group attempts to formulate an FJS problem as a mixed-integer program; however, such a mathematical programming approach is only suitable for solving small-sized FJS problems due to high computational complexity. Recent examples of the mathematical programming approach can be referred [20,12,36]. The second group attempts to solve the FJS problems by heuristics and meta-heuristics. In general, meta-heuristics can obtain better quality solution than simple heuristics but requires longer computation time. In developing meta-heuristics on solving FJS problems, the form of solution encoding (i.e., chromosome representation) may significantly affect the solution quality. Many meta-heuristic algorithms for solving FJS problems can be referred [26,15,16,13,35,37,28,14].

Fig. 1. Scenario of a DFJS problem.

In solving DFJS problems, the earliest studies are by Chan et al. [5] in which a GA with dominated genes is proposed. They further proposed a mathematical formulation of DFJS problems [6]; and extend their GA to solve a DFJS problem which additionally considers the decision of machine maintenance [7]. Using various chromosome representations, prior studies developed the following three GAs: IGA [11], GA_CL [8], and GA_ JS [30]. Other than the track of GA, Ziaee [38] developed a heuristic algorithm, which requires much less computation time but is inferior to the IGA in terms of solution quality. Prior studies claimed that IGA outperforms GADG; in addition, both GA_ JS and GA_CL outperform IGA. Yet, these claims are based on different DFJS problem instances. To make a fair comparison, we take IGA, GA_CL, and GA_ JS as the three benchmarks for evaluating our proposed genetic algorithm (called GA_OP). 3. DFJS problem A distributed and flexible job-shop scheduling (DFJS) problem consists of a set of manufacturing cells U = {U1 ,…, Uq } and a set of jobs J = {J1 ,…, Jn }. As shown in Fig. 1, an input/output center (I/O center) is established for moving jobs to these manufacturing cells. The DFJS problem is to determine how to allocate these n jobs to suitable cells and determine the production scheduling of each cell. Notation and assumptions made for describing the DFJS problems are listed below. Notation n: total number of jobs to be scheduled Ji : ith job Oij : jth operation of job Ji , Ul : Lth cell Mlh : hth machine in cell Ul Hl : total number of machines in cell Ul plh : processing time of operation Oij on machine Mlh ij dil : transportation time required to move job Ji from I/O center to cell Ul and back to I/O center Assumptions (1) Each job can only be processed in only one cell (i.e., cross-cell production is prohibited). (2) Each operation when processed by different machines may have different efficiencies. (3) Not all machines can process each operation. (4) Preemption is not allowed (i.e., an operation while in process cannot be interrupted). (5) A transportation time is required to move a job from the I/O center to each cell and back to the I/O center. As shown in Table 1, the DFJS example problem has three jobs (J1 , J2 , J3 ) and two cells (U1 , U2 ). The transportation time of

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112 Table 1 An example of DFJS problem represented by Job-Cell-Op table. U1

J1

J2

J3

O11 O12 O13 O21 O22 O23 O31 O32 O33

U2

di1

M

2

1 4 2 3 4 1 – 6 4

2

2

11

M 2 3 – 2 2 3 1 3 –

12

di2

M21

M22

1

4 2 4 – 3 4 4 2 1

2 – – 3 4 3 2 3 2

1

1

moving job J1 from the I/O center to cell U1 and back to the I/O center is d11 = 2. The processing time of operation O11 on M11 is 12 is p12 = 2. In the p11 11 = 1, and the processing time of O11 on M 11 table, “plh = −“ denotes that O cannot be processed by Mlh . ij ij The DFJS problem involves three scheduling decisions: (1) job-to-cell assignment, (2) operation-to-machine assignment, and (3) operation-sequencing. The job-to-cell assignment is to assign each job to a cell. Then, each cell involves a set of jobs and their associated operations. In turn, for each cell, the operation-tomachine assignment is to assign each operation to a particular machine. After each operation has been assigned to a machine, each machine may involve many operations. Therefore, we have to make the operation-sequencing decision for each machine in order to yield the Gantt chart of each machine. As a result, the completion times for processing each job can be obtained. The objective of the DFJS problems is to minimize the global makespan. Like all prior DFJS studies, the makespan of a job denotes the sum of its completion time of processing and transportation time. In turn, the makespan of a cell (also called local makespan in prior studies) is defined as the maximum makespan of all jobs in the cell. The global makespan is the maximum of all local makespans; and the cell which yields the global makespan is called the critical cell.

103

In summary, the SCH chromosome representation explicitly models each of the three DFJS scheduling decisions: (1) job-tocell assignment, (2) operation-to-machine assignment, and (3) operation-sequencing. 4.2. SGP chromosome representation See Fig. 2(b), an SGP chromosome denotes a DFJS solution by a sequence of all operations (i.e., each gene models an operation). An SGP chromosome also involves 9 genes in the example DFJS problem. But now each gene models an operation by a 2-tuple vector. See the figure, the first gene is (2,3) in which the 1st element denotes a cell (U2 ), and the 2nd element denotes a job (J3 ). This implies that job J3 is assigned to cell U2 . Moreover, the first appearance of job J3 implies that this gene denotes operation O31 (i.e., the 1st operation of job J3 ). The corresponding operation of the other genes can be identified accordingly. In summary, of the three DFJS scheduling decisions, SGP chromosome representation models only two ones: (1) job-to-cell assignment and (2) operation-sequencing. The operation-tomachine assignment decision is obtained by a heuristic rule (Giovanni and Pezzella) [11], which is designed toward achieving a load-balance for all machines in each cell. 4.3. SJS chromosome representation See Fig. 2(c), an SJS chromosome represents a DFJS solution by a sequence of all jobs (i.e., each gene models a job). Now an SJS chromosome involves only 3 genes in the example DFJS problem. See the figure, the chromosome (3, 1, 2) denotes that a job sequence J3 →J1 →J2 . An SJS chromosome can be decoded to yield a DFJS solution by applying three heuristic rules [30], which are designed to generate a DFJS solution toward achieving a load-balance among all cells and a load-balance for all machines in each cell. In summary, of the three DFJS scheduling decisions, the SJS chromosome representation does not explicitly represent any one of them. The three scheduling decision are all obtained by heuristic decoding rules.

4. Comparison of chromosome representations 4.4. SCL chromosome representation This section compares the proposed chromosome representation SOP against four prior ones SCH , SGP , SJS, and SCL , in which SCH is proposed by Chan et al. [5,6], SGP is by Giovanni and Pezzella [11], SJS is by Lu et al. [30], and SCL is by Chang and Liu [8]. These chromosome representations are explained by referring to the DFJS problem which involves 3 jobs and 9 operations as shown in Table 1. A conjecture is finally proposed to explain why the proposed SOP might outperform the other four chromosome representations. 4.1. SCH chromosome representation See Fig. 2(a), an SCH chromosome represents a DFJS solution by a sequence of all operations (i.e., each gene models an operation). Therefore, in the example DFJS problem, an SCH chromosome involves 9 genes. Each gene models an operation by a 5-tuple vector. The first gene is (2,2,3,1,1) in which the 3rd and 4th elements are used to denote that the operation is O31 . Moreover in the gene (2,2,3,1,1), the 1st element denotes the job-to-cell assignment decision, and the 2nd element denotes the operation-to-machine assignment decision. That is, job J3 is assigned to cell U2 , and operation O31 is assigned to machine M22 . Finally, the 5th element is a binary variable, in which 1 denotes that the gene is a dominated one and 0 denotes a non-dominated one. A dominated gene shall be inherited while generating its offspring chromosome.

See Fig. 2(d), an SCL chromosome represents a DFJS solution by a sequence of all operation (i.e., each gene models an operation). An SCL chromosome also involves 9 genes in the example DFJS problem. Now each gene models an operation by a real number (1tuple vector). See the figure, the 1st gene is 3.84 in which the integer part 3 denotes that the operation belongs to job J3 ; in turn, this gene denotes operation O31 since J3 appear the first time. Likewise, the 8th gene value 3.98 denotes operation O33 ; and the operations represented by the other genes can be accordingly decoded. In the 1st gene, following a decoding method, the decimal part 0.84 denotes that operation O31 is assigned to machine M22 (2nd machine in cell U2 ). This operation-to-machine assignment results in a jobto-cell assignment; that is, job J3 is assigned to cell U2 . Once the 1st operation of a job has been assigned to a cell (U2 ), the remaining operations of the job must be assigned to cell U2 . In summary, the SCL chromosome explicitly models each of the three DFJS scheduling decisions: (1) job-to-cell assignment, (2) operation-to-machine assignment, and (3) operation-sequencing. 4.5. SOP chromosome representation The chromosome representation SOP is adopted from the solution encoding method proposed by Bierwirth [2] in solving a job shop scheduling problem. Extending from this idea, we propose a

104

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

Fig. 2. Five chromosome representations for solving DFJS problems: (a) SCH (b) SGP (c) SJS (d) SCL (e) SOP .

few load-balance heuristic rules to decode chromosome SOP in order to solve a DFJS scheduling problem, which is much more complex than a job shop scheduling problem. See Fig. 2(e), SOP models a scheduling solution by a sequence of operations (i.e., each gene represents an operation). An SOP chromosome involves 9 genes in the example DFJS problem. Each gene models an operation by its job index (an integer). For example, the first gene (job index = 3) implies that the operation belongs to J3 ; in turn, this gene represents operation O31 because it is the 1st operation of J3. The operations represented by the other genes can be likewise decoded. In summary, of the three DFJS scheduling decisions, the SOP models only the operation sequence decision. The other two scheduling decisions are decoded by two heuristic rules which are designed toward achieving a load-balance among all cells and a load-balance for all machines in each cell.

4.6. Conjectures on chromosome representation Of the three DFJS scheduling decisions, both SCH and SCL chromosomes explicitly represent each decision: (1) job-to-cell assignment, (2) operation-to-machine assignment, and (3) operation sequencing decision. In contrast, SGP chromosomes represent only two decisions: (1) job-to-cell assignment and (2) operation sequencing decision. As a result, in the three chromosome repre-

sentations (SCH, SCL , and SGP ), the job-to-cell assignment decisions have to be generated by genetic operators. Lu et al. [30] conjectured that load-balance among cells (called cell-load-balance) and load-balance among machines in each cell (called machine-load-balance) are two critical criteria in justifying the scheduling quality of a chromosome. That is, the two job-to-cell and operation-to-machine assignment decisions had better be made toward load-balance based heuristic rules rather than by genetic operators (i.e., crossover or mutation). The use of genetic operators has a lower tendency to generate chromosomes with good cell-load-balance and machine-load-balance features. As a result, the evolutionary process of genetic algorithm tends to be locally trapped. Namely, the two job-to-cell and operation-tomachine assignment decisions might have been locally trapped to a “mediocre” decision; yet the GA is still working on finding an optimum operation sequence under the “mediocre” assignment decision. This conjecture is empirically supported by the numerical experiments of Lu et al. [30], in which their developed genetic algorithm (GA_ JS) outperforms IGA in solving the DFJS problems. Extending from the conjecture of Lu et al. [30], we develop the SOP chromosome representation, which is an extension of SJS by including operation sequence in the chromosome. Such an inclusion increases the search space of operation sequencing decisions while targeting the two criteria of cell-load-balance and machine-load-balance. Therefore, we conjecture that the proposed

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

105

Fig. 3. Decoding SOP chromosome by D1 and D2 heuristic rules.

algorithm GA_OP (a GA embedded with SOP chromosomes) may outperform GA_ JS (a GA embedded with SJS chromosomes) in solving DFJS problems. Experiments results supports this conjecture, as stated in a later section. Notice that the search space of GA_OP and that of GA_ JS are not dominant due to the use of a cell-load-balance and a machineload-balance decoding rules. Accordingly, the search space of IGA is also not dominant due to the use of a machine load-balance decoding rule. Prior studies reveal that a genetic algorithm with a dominant search space may not yield better solution. For example, the search space of the genetic algorithm developed by Chan et al. [5] is dominant. Yet, its obtained solution is inferior to that of IGA developed by Giovanni and Pezzella [11], in which the search space is not dominant. 5. Decoding of SOP chromosomes This section presents the decoding method which converts the proposed SOP chromosome representation into a DFJS scheduling solution. Based on SOP , two heuristic rules (D1 and D2) are developed to obtain the three scheduling decisions of a DFJSP. In the following, the D1 and D2 heuristic rules are explained by referring to the example DFJS problem in Table 1 and notation in Section 3. 5.1. Heuristic rule D1 Given an SOP chromosome (called 0 ), heuristic rule D1 is designed to determine the job-to-cell assignment decision. As shown in Fig. 3, the procedure of D1 involves three major steps. Procedure D1 Step 1: For chromosome 0 , determine its implied job sequence (called job ).

Table 2 Job-Cell table used for making job assignment decision.

J1 J2 J3

U1

U2

7 7.5 9.5

9 10 7

Step 2: Reduce the Job-Cell-Op table (Table 1) to the Job-Cell table (Table 2). Step 3: Based on the Job-Cell table (Table 2), assign jobs to cells. In Step 1, we derive a job sequence job from chromosome 0 by selecting the 1st operation of each job in 0 and maintaining the sequence of these selected operations. For example, in Fig. 3, chromosome 0 is O31 →O11 →O12 →O32 →O21 →O22 →O13 →O33 →O23 and its implied job sequence job is J3 →J1 →J2 . In Step 2, we attempt to compute the average processing time pli for each job (Ji ) in each cell (Ul ) to obtain a Job-Cell table. Referring to Table 1, each element ( pli ) in Table 2 is obtained by the for  mula: pli = j pi jl where pi jl = h plh /Hl denotes the average proij cessing time of operation Oij in cell Ul . See Table 1, p111 = (1 + 2) / 2 = 1.5, p121 = (4 + 3)/2 = 3.5 and p131 = (2.0)/1 = 2.0. As a result,  p11 = j p1 j1 = ( p111 + p121 + p131 ) = (1.5 + 3.5 + 2.0) = 7.0 Each element in Table 2 can be accordingly obtained. In Step 3, following the job sequence job (J3 →J1 →J2 ), we successively assign each job to a particular cell by taking a makespan minimization strategy. As shown in Fig. 4, the Gantt charts of the two cells are iteratively displayed while we try to assign a job to one of the two cells. The objective of the job-to-cell assignment is to minimize the makespan of the two cells. For example, in

106

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

Fig. 4. The process of heuristic rule D1 in assigning jobs to cells. Table 3 Operation-to-Machine assignment by heuristic rule D2. plh ij M O11 O12 O21 O22 O13 O23

1 4 3 4 2 1

11

Try Mlh _Load M

12

2 3 2 2 3

M 1 5 4 8 6 7

11

M 2 3 5 5 8

12

Update Mlh _Load Select

M11

M12

M11 M12 M11 M12 M11 M11

1 1 4 4 6 7

0 3 3 5 5 8

Fig. 4(a), job J3 shall be assigned to cell U2 because its expected makespan in U2 is shorter. Comparing the makespans of the two cells in Fig. 4(b), job J1 shall be assigned to U1 . Likewise, in Fig. 4(c), job J2 shall be assigned to U1 . Fig. 4(d) shows the results of the job-to-cell assignment decision. 5.2. Heuristic rule D2 As stated above, by using heuristic rule D1, each job is assigned to a cell. Then, from chromosome 0 , we can extract an operation sequence in each cell Ul (called l ) by selecting operations in  Cop that have been as0 signed to cell Ul . As stated, the chromosome 0 is O31 →O11 →O12 →O32 →O21 →O22 →O13 →O33 →O23 ; cell U1 involves 1 is O →O →O →O →O →O ; jobs J1 and J2 . Therefore, Cop 11 12 21 22 13 23 2 and Cop is O31 →O32 →O33 because cell U2 involves only job J3 . Now using heuristic rule D2, we can successively assign each l to a machine in cell Ul by exhaustive comparison. operation in Cop l to each of its all That is, we try to assign each operation in Cop possible machines, and select the machine which has the lowest workload. Table 3 shows the process of assigning each operation in 1 (O →O →O →O →O →O ) to one of the two machines Cop 11 12 21 22 13 23 (M11 or M12 ). Consider the first two rows in Table 3. In the 1st row, we try to assign operation O11 to machine M11 or M12 ; M11 is selected due to having lower workload; then we update the workload of each machine. In the 2nd row, we proceed to assign operation O12 to M11 or M12 ; now machine M12 is selected due to having lower workload; again we update the workload of each machine. Following the above procedure, Table 3 reveals that operations O11 , O21 , O13 , O23 are assigned to machine M11 , and operations O12 , O22 are assigned to machine M12 .

Applying heuristic rules D1 and D2, we can decode the chromosome 0 (O31 →O11 →O12 →O32 →O21 →O22 →O13 →O33 →O23 ) and obtain two scheduling decisions (job-to-cell assignment and operation-to-machine assignment decisions). In turn, following the operation sequence in 0 , we can obtain the operation sequencing decision of each machine. As a result, the three scheduling decisions of the DFJS problem can be obtained and yields a Gantt Chart as shown in Fig. 5. 6. Algorithmic flow of GA_OP To compare the effect of chromosome representations, the algorithmic flow of GA_OP is similar to that GA_ JS and IGA except that their chromosome representations (SOP , SJS , SGP ) are substantially different. In the following, we present the procedure of the proposed algorithm GA_OP, in which N, ρ c , ρ m , kb , φ f , and φ max are given parameters. Procedure GA_OP Randomly create an initial population of N chromosomes, say set P. Repeat (outer loop) Repeat (inner loop) Select two parent chromosomes from P randomly Apply crossover with probability ρ c to the two chromosomes and update P Apply mutation with probability ρ m to the two chromosomes and update P Until inner loop iterates N times For each of the best kb chromosomes in P Apply critical-cell refinement to the chromosome and update P Endfor Until either one of the following two termination conditions appears; • The up-to-date best solution has not changed for φ f outer loop iterations • The total number of outer loop iterations equals φ max Output the up-to-date best solution

As stated above, the procedure GA_OP includes three subprocedures: crossover, mutation, and critical-cell refinement. Each of the three sub-procedures is explained below. The crossover operator, designed to generate two new chromosomes (offspring chromosomes) from two existing chromosomes (parent chromosomes), is a two-point crossover developed by Bierwirth [2]. As shown in Fig. 6(a), it randomly divides the two parent chromosomes (A, B) into three substrings (A1 -A2 -A3 , B1 -B2 B3 ). Then, two offspring chromosomes B1 -X-B3 and A1 -Y-A3 are generated. String X is generated by two steps. First, we select the genes of B1 (i.e., 2-3) and delete them from chromosome A following a left-to-right sequence. Second, we select the genes of B3 (i.e.,

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

107

Fig. 5. Gantt Chart of SOP chromosome 0 , where U1 is the critical cell and π 0 is the sub-chromosome.

Fig. 6. (a) Two-point crossover operator, (b) mutation operator.

1-2) and delete them from chromosome A following a right-to-left sequence. String X is the remaining gene sequence (i.e., 1-1-3-2-3) in chromosome. Accordingly, string Y can also be generated. Of the two chromosomes A1 -A2 -A3 and B1 -X-B3 , the better one is selected. Likewise, of the two ones (B1 -B2 -B3 and A1 -Y-A3 ), the better one is also selected. The two selected chromosomes are then placed in set P and the other two ones are deleted from set P. The mutation operator is designed to generate one offspring chromosome from one parent chromosome. It randomly chooses two genes (operations) and exchanges their gene values as shown in Fig. 6(b). Of the parent and its offspring chromosomes, we select the better one and delete the worse one for updating set P. In the sub-procedure critical-cell refinement, the critical cell is the cell with maximum local makespan; for example, cell U2 is the critical cell in Fig. 5. Adapted from Giovanni and Pezzella [11], the critical-cell refinement method is designed to improve the scheduling performance of the critical cell by changing the operation sequencing. This in turn changes the operation-to-machine assignment decisions in the critical cell;

and may yield a new chromosome that shall be included in set P. To explain the critical-cell refinement method, we define the following notation. Hereafter, 0 denotes a particular chromosome of a DFJS problem; Uc denotes its critical cell; and π 0 (also called the sub-chromosome of 0 ) denotes its operation sequence in the critical cell Uc . See the DFJS example in Fig. 5, the critical cell Uc is U1 ; the chromosome 0 and sub-chromosome π 0 are respectively shown as follows.

0 = O31 → O11 → O12 → O32 → O21 → O22 → O13 → O33 → O23

π0 = O11 → O12 → O21 → O22 → O13 → O23 Now we attempt to apply the critical-cell refinement method to chromosome 0 . As shown in Fig. 7, the critical cell refinement method is designed to exhaustively swap any two operations on the sub-chromosome π 0 within the critical cell (Uc ) in order to obtain better scheduling performance. To avoid infeasible swapping, we model π 0 by replacing each of its operations by its associated job. For example, opera-

108

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112 Table 4 Genetic parameters used in Experiment 1. Type

DFJS

N

100 0.3 10 0 0

ρm φf

Table 5 Genetic parameters used in Experiments 2, 3, 4, and 5.

Fig. 7. Exhaustive pair wise swapping used in the critical cell refinement method.

tion sequence O11 →O12 →O21 →O22 →O13 →O23 is represented by J1 →J1 →J2 →J2 →J1 →J2 . Notice that each job appears several times in the sequence, in which the nth appearance of a job denotes its nth operation. Now, assume the first two operations are swapped; this yields a new sequence J1 →J1 →J2 →J2 →J1 →J2 which can be interpreted as O11 →O12 →O21 →O22 →O13 →O23 . Such a swapping method may produce a “virtually new” job sequence which in fact is the same as the original job sequence. When such a “virtually new” sub-chromosome is detected, we skip the evaluation of the “virtually new” sub-chromosome in order to save computation time. For example, the swapping of two “J1 ” yields the same job sequence and the generated “virtually new” job sequence does not need evaluation. The critical cell refinement method is essentially a neighborhood search method which can be replaced or enhanced by using some other neighborhood search methods [31,14,19]. Therefore, applying a pair-wise swapping to π 0 implies the generation of a new sub-chromosome (π k ) in the critical cell. By the exhaustive pairwise-swapping method, we can successively generate many new sub-chromosomes in critical cell Uc . For each new sub-chromosome (π k ), we can apply heuristic rule D2 to make a new operation-to-machine assignment. This in turn yields a new scheduling solution in the critical cell. In the critical-cell refinement process, when the following two cases appear, we must change the subject and scope of the swapping process. In addition, we may have to update chromosome 0 . The first case is called subject change. If the makespan of new sub-chromosome π k is better than that of π 0 , then we must change the to-be-refined sub-chromosome (i.e., π 0 ← π k ). Due to this sub-chromosome replacement (π 0 ← π k ), the chromosome 0 is updated. Then, we restart the exhaustive pairwise-swapping process on the updated chromosome 0 . The second case is called scope change. If the makespan of the original critical cell Uc is greatly reduced by the swapping process; and another cell (Uk ) become the new critical cell. Then, we have to update the critical cell (Uc ← Uk ). To reflect the change of critical cell, chromosome 0 and its sub-chromosome π 0 must be updated. In turn, we restart the exhaustive pairwise-swapping process on the updated chromosome 0 . The swapping process is iteratively carried out until the makespan of the up-to-date critical cell Uc cannot be improved further. After completing the refinement process, we shall record the best scheduling solution that appears in the refinement process. Additionally, once chromosome 0 has been updated in the critical-cell refinement process, we have to update set P by including the updated chromosome 0 and deleting the original one. 7. Numerical experiments In this section, we compare the performance of the proposed algorithm GA_OP against recent prior algorithms. Five experiments are carried out. Experiments 1-4 address DFJS problems with

Type

2 Instances (DFJSP 2, DFJSP 3)

23 Other Instances

N

100 0.9 0.9 3 3750 50 0 0

50 0.9 0.9 3 225 300

ρc ρm kb

φf φ max

various cells; and Experiment 5 addresses FJS problems (i.e., 1-cell DFJS problems). The benchmark algorithms for Experiment 1-4 involve GA_ JS [30], GA_CL, [8], and IGA [11]. The benchmark algorithm for Experiment 5 is HA (Li and Gao) [29]. For each problem instance in the five experiments, we carried out 30 replicates. Our proposed algorithm GA_OP is implemented in C++ and run on a personal computer equipped with a 3.0 GHz AMD Athlon(tm) II∗ 4640 processor and 4GB RAM. The processors and memory for the benchmark algorithms are listed in the experiment results reported later. Experiment 1 involves 6 DFJS instances (Table 4), which is adopted from Chang and Liu [8]. Of these 6 DFJS instances, one addresses a 3-cell scenario, and the other ones address 2-cell scenarios. Four algorithms (GA_OP, GA_ JS, IGA, and GA_CL) are compared in Experiment 1. The genetic parameters of GA_OP, GA_ JS, and GA_CL are set the same as shown Table 4; the genetic parameters of IGA [11] are different. Experiment 2 involves 25 DFJS instances, which is adopted from Giovanni and Pezzella [11]. Each DFJS instance deals with a 2-cell scenario; notice that each of the two cells is exactly the same. In Chang and Liu [8], experiment results of the 25 DFJS instances are not available. Therefore, we compare only three algorithms GA_OP, GA_ JS, and IGA in this experiment. The genetic parameters of the three algorithms are set the same as shown in Table 5, in which 2 instances (DFJSP 2 and DFJSP 3) forms a category and the remaining 23 instances form the other category. Experiment 3, adopted from Giovanni and Pezzella [11] involves only 23 DFJS instances. Each DFJS instance deals with a 3-cell scenario. The jobs to be scheduled are the same as that in Experiment 2, but one more cell is included in the experiment. Namely, the capacity is increased by 1.5 times as that of Experiment 2. Experiment 4, adopted from Giovanni and Pezzella [11], also involves 23 DFJS instances. The jobs to be scheduled are the same as that in Experiment 2, but two more cells are included in the experiment. Namely, the capacity is increased by 2 times as that of Experiment 2. We compare three algorithms GA_OP, GA_ JS, and IGA in Experiments 3 and 4. The genetic parameters of the three algorithms are set the same as shown in Table 5. Experiment 5, adopted from Li and Gao [29], is used to test the effectiveness of the GA_OP in solving an FJS problem (i.e., 1-cell DFJS problem). Of the several benchmark algorithms, HA developed by Li and Gao [29] is the state-of-the-art algorithm on solving FJS problems. Notice that the application scope of GA_OP is substantially larger than that of HA. That is, GA_OP can be used to solve a multiple-cell DFJS problem, yet HA can only be used to solve an FJS problem (i.e., 1-cell DFJS problem). Therefore, a performance comparison between GA_OP and HA in the FJS context

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

109

Table 6 Performance comparison of 2-cell or 3-cell DFJS algorithms in Experiment 1. IGAa Giovanni and Pezzella Inst. DFJSP 1 DFJSP 2 DFJSP 3 MK1 MK2 MK3 a b c

Job∗ Op

Ref [11] [5] [7] [8] [8] [8]

∗

5 1∼3 10∗ 4 10∗ 4 20∗ 5∼6 20∗ 5∼6 30∗ 10

GA_CLb Chang and Liu

GA_ JSc Lu et al.

GA_OPc Our proposed Algorithm

Cell

MK

Av.

T(s)

Dev%

MK

Av.

T(s)

Dev%

MK

Av.

T(s)

Dev%

MK

Av.

T(s)

Dev%

3 2 2 2 2 2

11 37 37 N/A N/A N/A

N/A 38.6 38.3 N/A N/A N/A

N/A 156 145.5 N/A N/A N/A

N/A 1.9 1.9 N/A N/A N/A

9 37 37 51 39 210

N/A 37.6 37.5 51.8 41.9 217.8

418 1241 1249 3236 3429 8603

N/A 0.4 0.6 0.3 1.8 6.9

9 38 38 45 35 208

9.0 38.0 38.2 45.6 35.5 208

1.3 6.1 4.4 99 113.2 2818.6

0.0 0.0 6.2 0.8 0.5 0.0

9 37 37 45 34 208

9 37 37 45.1 34.4 208

0.8 4.0 4.0 92.8 106.5 3073

0.0 0.0 0.0 1.1 0.8 0.0

The CPU time on a 2.0 GHz Intel Core2 processor with 2.0 GB of RAM memory in C++. The CPU time on a 3.3 GHz Intel Xeon E3-1230 V2 processor with 32.0 GB of RAM memory in Matlab. The CPU time on a 3.0 GHz AMD Athlon (TM) II × 4640 processor with 4.0 GB of RAM memory in C++.

Table 7 Performance comparison of 2-cell DFJS algorithms in Experiment 2. IGAa Giovanni and Pezzella

GA_ JSb Lu et al.

GA_OPb Our proposed Algorithm

Inst.

Jobs∗ Ops

LB

MK

Av.

T(s)

Dev%

Gap%

MK

Av.

T(s)

Dev%

Gap%

MK

Av.

T(s)

Dev%

Gap%

DFJSP 2 DFJSP 3 la01 la02 la03 la04 la05 la06 la07 la08 la09 la10 la11 la12 la13 la14 la15 la16 la17 la18 la19 la20 mt06 mt10 mt20

10∗ 4 10∗ 4 10∗ 5 10∗ 5 10∗ 5 10∗ 5 10∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 10∗ 10 10∗ 10 10∗ 10 10∗ 10 10∗ 10 6∗ 6 10∗ 10 20∗ 5

26 26 413 394 349 369 380 413 376 369 382 443 413 408 382 443 378 717 646 663 617 756 47 655 387

37 37 413 394 349 369 380 445 412 420 469 445 570 504 542 570 584 717 646 663 617 756 47 655 560

38.6 38.3 413.0 394.0 349.0 369.0 380.0 449.6 419.2 427.8 474.6 448.6 571.6 508.0 552.2 576.0 588.8 717.0 646.0 663.0 617.2 756.0 47.0 655.0 566.0

156.0 145.5 12.0 11.2 10.8 11.4 8.0 45.8 50.2 53.8 45.2 45.0 126.0 116.0 125.4 122.2 119.6 140.2 112.6 132.4 147.2 99.8 2.0 173.0 121.2

1.9 1.9 0.0 0.0 0.0 0.0 0.0 0.6 1.1 1.6 0.8 0.5 0.3 0.1 1.0 1.2 0.7 0.0 0.0 0.0 0.1 0.0 0.0 0.0 0.9

42.3 42.3 0.0 0.0 0.0 0.0 0.0 7.7 9.6 13.8 22.8 0.5 38.0 23.5 41.9 28.7 54.5 0.0 0.0 0.0 0.0 0.0 0.0 0.0 44.7

38 38 413 394 349 369 380 421 396 406 447 443 548 483 530 545 554 717 646 663 617 756 47 655 530

38.0 38.0 413.0 394.0 349.0 369.0 380.0 435.8 408.5 417.4 459.0 444.1 557.1 492.5 538.4 557.3 568.7 717.0 646.0 663.0 622.1 756.0 47.0 655.0 547.7

96.7 99.5 7.1 6.6 7.0 6.4 6.6 25.8 26.3 26.4 27.0 24.9 64.6 65.5 66.1 63.3 63.6 53.3 52.0 53.9 58.4 53.9 3.4 54.0 59.5

0.0 0.0 0.0 0.0 0.0 0.0 0.0 8.3 7.4 6.1 6.8 3.4 5.7 5.6 5.5 5.9 6.2 0.0 0.0 0.0 8.3 0.0 0.0 0.0 9.5

46.2 46.2 0.0 0.0 0.0 0.0 0.0 1.9 5.3 10.0 17.0 0.0 32.7 18.4 38.7 23.0 46.6 0.0 0.0 0.0 0.0 0.0 0.0 0.0 37.0

37 37 413 394 349 369 380 424 390 397 444 443 541 474 529 544 554 717 646 663 617 756 47 655 525

37.0 37.1 413.0 394.0 349.0 369.0 380.0 432.7 403.6 411.7 455.7 443.2 549.9 482.3 538.1 553.7 566.6 717.0 646.0 663.0 617.5 756.0 47.0 655.0 534.4

57.5 58.2 4.7 4.7 5.2 5.0 5.0 23.9 24.6 23.7 24.1 21.9 62.5 63.9 62.3 63.0 63.1 47.8 48.7 48.7 57.9 48.3 2.4 49.6 61.4

0.2 0.3 0.0 0.0 0.0 0.0 0.0 5.4 5.6 5.8 6.4 0.5 5.3 4.4 6.0 5.3 6.8 0.0 0.0 0.0 1.6 0.0 0.0 0.0 5.3

42.3 42.3 0.0 0.0 0.0 0.0 0.0 2.7 3.7 7.6 16.2 0.0 31.0 16.2 38.5 22.8 46.6 0.0 0.0 0.0 0.0 0.0 0.0 0.0 35.7

Average a b

85.3

14.8

42.9

12.9

37.5

12.2

The CPU time on a 2.0 GHz Intel Core2 processor with 2.0 GB of RAM memory in C++. The CPU time on a 3.0 GHz AMD Athlon (TM) II× 4640 processor with 4.0 GB of RAM memory in C++.

may not be justified on an equal basis. However, the purpose of Experiment 5 is to provide a reference to those researchers who are interested in solving FJS problems. Tables 6, 7, 8, 9, and 10 respectively show the results of the five experiments. In the five tables, LB reports a lower bound proposed by Giovanni and Pezzella [11] and Mastrolilli and Gambardella [31]; MK denotes the best makespan of all replicates in an instance; Av. denotes the average makespan of all replicates in an instance; T(s) denotes the average computation time in seconds; Dev%=(Deviation (Makespan of Replicates)) ÷ (Av.) and Gap%=(MK−LB) ÷ LB. Table 6 displays the experiments results of the 6 DFJS instances in Experiment 1. This table reveals that GA_OP outperforms the other three benchmark algorithms. Of the 6 DFJS instances, it reveals that GA_OP always ranks 1st in terms of MK, Av., and Dev%. This implies that GA_OP outperforms the other three benchmark algorithms in terms of solution quality. One may observe that GA_OP also ranks 1st in terms of computation time; however, such a comparison is for reference only due to that different algorithms may use different computing equipments. As stated, Experiments 2, 3, and 4 involves at least 23 DFJS instances. To make a justified comparison among various algorithms

in these three experiments, we carry out a paired t-test as stated below. The t-test statistic for modeling the performance difference is defined as d=(AV1 −AV0 ) ÷ AV1 where AV0 denotes the average performance of GA_OP and AV1 denotes the average performance of a benchmark algorithm (e.g., IGA, GA_CL, GA_JS, and HA). The √ t-value is t0 = d¯/(Sd / n ) where n is the number of instances d¯ is the mean and Sd is the standard deviation of d. In the case of n = 23, if t0 > t0.025, 22 = 2.07, this implies that GA_OP outperforms the benchmark algorithm with statistical significance. Table 7 displays the 25 DFJS 2-cell instances in Experiment 2. This table reveals that GA_OP ranks 1st in 24 instances in terms of MK and Gap%; ranks 1st in n = 25 instances in terms of Av.; and ranks 1st in 25 instances in terms of Dev%. This appears that GA_OP outperforms the two benchmark algorithms (IGA and GA_ JS). To statistically justify the above finding, we carry out a t-test which shows that GA_OP outperforms GA_ JS (t = 3.81 > t(0.05 , 24) = 2.06) and GA_OP outperforms IGA (t = 4.72> t(0.05 , 24) = 2.06). In addition, one may observe that GA_OP also ranks 1st in terms of computation time; this is for reference only as stated above.

110

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112 Table 8 Performance comparison of 3-cell DFJS algorithms in Experiment 3. IGAa Giovanni and Pezzella Inst. la01 la02 la03 la04 la05 la06 la07 la08 la09 la10 la11 la12 la13 la14 la15 la16 la17 la18 la19 la20 mt06 mt10 mt20

Jobs∗ Ops ∗

10 5 10∗ 5 10∗ 5 10∗ 5 10∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 10∗ 10 10∗ 10 10∗ 10 10∗ 10 10∗ 10 6∗ 6 10∗ 10 20∗ 5

b

GA_OPb Our proposed Algorithm

LB

MK

Av.

T(s)

Dev%

Gap%

MK

Av.

T(s)

Dev%

Gap%

MK

Av.

T(s)

Dev%

Gap%

413 394 349 369 380 413 376 369 382 443 413 408 382 443 378 717 646 663 617 756 47 655 387

413 394 349 369 380 413 376 369 382 443 425 408 419 443 451 717 646 663 617 756 47 655 439

413.0 394.0 349.0 369.0 380.0 413.0 376.0 369.0 387.4 443.0 436.8 408.0 430.2 448.8 456.0 717.0 646.0 663.0 617.0 756.0 47.0 655.0 442.6

4.6 3.6 3.8 3.8 2.6 17.4 18.2 19.6 17.8 17.0 50.6 44.6 45.8 48.8 42.2 36.0 31.6 36.8 62.4 34.2 1.0 50.0 48.2

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.3 0.0 1.7 0.0 1.6 1.2 1.6 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.6

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 2.9 0.0 9.7 0.0 19.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 13.4

413 394 349 369 380 413 376 369 382 443 413 408 396 443 413 717 646 663 617 756 47 655 407

413.0 394.0 349.0 369.0 380.0 413.0 376.0 369.0 382.0 443.0 419.3 408.0 407.6 443.0 423.7 717.0 646.0 663.0 617.0 756.0 47.0 655.0 415.8

4.5 4.4 4.6 4.4 4.4 10.3 11.2 10.6 12.8 10.7 31.2 23.5 31.9 23.5 32.6 26.4 25.1 26.1 25.8 25.2 2.7 25.8 33.0

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 6.8 0.0 6.0 0.0 6.9 0.0 0.0 0.0 0.0 0.0 0.0 0.0 5.5

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 3.7 0.0 9.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 5.2

413 394 349 369 380 413 376 369 382 443 413 408 395 443 417 717 646 663 617 756 47 655 397

413.0 394.0 349.0 369.0 380.0 413.0 376.0 369.0 382.0 443.0 418.0 408.0 408.4 443.0 430.0 717.0 646.0 663.0 617.0 756.0 47.0 655.0 412.7

3.0 3.0 3.1 3.0 2.9 7.9 9.1 8.7 11.0 8.4 28.9 22.1 29.6 23.1 30.5 21.1 21.1 20.6 20.2 20.8 1.8 21.8 29.5

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 7.6 0.0 6.6 0.0 5.9 0.0 0.0 0.0 0.0 0.0 0.0 0.0 9.0

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 3.4 0.0 10.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 2.6

Average a

GA_ JSb Lu et al.

27.9

2.0

17.9

0.8

15.3

0.7

The CPU time on a 2.0 GHz Intel Core2 processor with 2.0 GB of RAM memory in C++. The CPU time on a 3.0 GHz AMD Athlon (TM) II× 4640 processor with 4.0 GB of RAM memory in C++.

Table 9 Performance comparison of 4-cell DFJS algorithms in Experiment 4. IGAa Giovanni and Pezzella

GA_ JSb Lu et al.

GA_OPb Our proposed Algorithm

Inst.

Jobs∗ Ops

LB

MK

Av.

T(s)

Dev%

Gap%

MK

Av.

T(s)

Dev%

Gap%

MK

Av.

T(s)

Dev%

Gap%

la01 la02 la03 la04 la05 la06 la07 la08 la09 la10 la11 la12 la13 la14 la15 la16 la17 la18 la19 la20 mt06 mt10 mt20

10∗ 5 10∗ 5 10∗ 5 10∗ 5 10∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 10∗ 10 10∗ 10 10∗ 10 10∗ 10 10∗ 10 6∗ 6 10∗ 10 20∗ 5

413 394 349 369 380 413 376 369 382 443 413 408 382 443 378 717 646 663 617 756 47 655 387

413 394 349 369 380 413 376 369 382 443 413 408 382 443 397 717 646 663 617 756 47 655 387

413.0 394.0 349.0 369.0 380.0 413.0 376.0 369.0 382.0 443.0 413.0 408.0 386.0 443.0 402.0 717.0 646.0 663.0 617.0 756.0 47.0 655.0 388.4

1.8 1.8 2.2 2.0 1.0 9.0 9.6 12.6 11.6 7.8 29.6 26.6 27.6 29.8 28.8 20.2 16.4 24.4 33.0 18.0 0.2 31.2 27.0

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 9.9 0.0 2.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 2.0

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0

413 394 349 369 380 413 376 369 382 443 413 408 382 443 378 717 646 663 617 756 47 655 387

413.0 394.0 349.0 369.0 380.0 413.0 376.0 369.0 382.0 443.0 413.0 408.0 382.0 443.0 381.9 717.0 646.0 663.0 617.0 756.0 47.0 655.0 387.0

4.4 4.3 4.4 4.3 4.4 7.9 8.3 8.2 8.4 7.9 15.7 15.9 17.6 15.2 20.3 16.2 15.2 17.3 16.1 15.4 2.4 17.1 17.1

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 4.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0

413 394 349 369 380 413 376 369 382 443 413 408 382 443 378 717 646 663 617 756 47 655 387

413.0 394.0 349.0 369.0 380.0 413.0 376.0 369.0 382.0 443.0 413.0 408.0 382.0 443.0 385.8 717.0 646.0 663.0 617.0 756.0 47.0 655.0 387.0

2.4 2.4 2.4 2.4 2.4 5.5 5.7 5.7 5.7 5.4 13.4 11.9 15.6 12.2 17.9 12.4 12.2 12.6 11.3 11.8 1.7 13.3 15.7

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 7.8 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0

0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0

Average a b

16.2

0.2

11.5

0.0

8.8

0.0

The CPU time on a 2.0 GHz Intel Core2 processor with 2.0 GB of RAM memory in C++. The CPU time on a 3.0 GHz AMD Athlon (TM) II× 4640 processor with 4.0 GB of RAM memory in C++.

Table 8 displays the results of Experiment 3. Of the n = 23 DFJS 3-cell instances, this table reveals that GA_OP and GA_ JS obtain lower bound solutions in 19 instances; and IGA obtains lower bound solutions in 17 instances. We carry out a t-test which shows that there is no significant difference between GA_OP and GA_ JS (t = 0.34 < t(0.05 , 22) = 2.07) and GA_OP is slightly better than IGA (t = 2.38 > t(0.05 , 22) = 2.07). The three algorithms (GA_OP, GA_ JS) appear to perform almost equally well in solving

3-cell DFJS instances. This may be due that the 3-cell experiments proposed by Giovanni and Pezzella [11] is a light-load scheduling problem (i.e., the number of jobs to be scheduled is the same as that in Experiment 2, but the capacity is increased by 1.5 times). As a result, it is very likely that the three algorithms can be used to obtain optimum solutions. Table 9 displays the results of Experiment 4. Of the n = 23 DFJS 4-cell instances, this table reveals that GA_OP and GA_ JS

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

111

Table 10 Performance comparison on solving FJS problems (1-cell DFJS problems) in Experiment 5. TSBM2 ha ˙ Bozejko et al. Inst. la01 la02 la03 la04 la05 la06 la07 la08 la09 la10 la11 la12 la13 la14 la15 la16 la17 la18 la19 la20 mt06 mt10 mt20 Average a b c d

Jobs∗ Ops ∗

10 5 10∗ 5 10∗ 5 10∗ 5 10∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 15∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 20∗ 5 10∗ 10 10∗ 10 10∗ 10 10∗ 10 10∗ 10 6∗ 6 10∗ 10 20∗ 5

PRMOTS+ISb Jia and Hu

PRMOTSb Jia and Hu

HAc Li and Gao

GA_OPd Our proposed Algorithm

LB

MK

T(s)

Gap%

MK

T(s)

Gap%

MK

T(s)

Gap%

MK

T(s)

Gap%

MK

Av.

T(s)

Dev%

Gap%

570 529 477 502 457 799 749 765 853 804 1071 936 1038 1070 1089 717 646 666 647 756 47 679 1022

574 532 482 509 462 801 751 767 856 807 1072 937 1039 1071 1090 N/A N/A N/A N/A N/A N/A N/A N/A

16.81 14.67 15.52 12.65 5.767 5.327 12.22 1.78 9.585 17.36 19.87 13.31 47.34 36.7 19.07 N/A N/A N/A N/A N/A N/A N/A N/A

0.70 0.57 1.05 1.39 1.09 0.25 0.27 0.26 0.35 0.37 0.09 0.11 0.10 0.09 0.09 N/A N/A N/A N/A N/A N/A N/A N/A

572 529 482 504 459 800 750 766 853 805 1071 936 1038 1070 1090 N/A N/A N/A N/A N/A N/A N/A N/A

22.8 19.7 25.6 31.2 32.5 29.7 28.7 33.3 26.3 29.5 32.6 37.6 31.9 35.4 37.5 N/A N/A N/A N/A N/A N/A N/A N/A

0.35 0 1.05 0.40 0.44 0.13 0.13 0.13 0.00 0.12 0 0 0 0 0.09 N/A N/A N/A N/A N/A N/A N/A N/A

572 530 478 502 458 799 750 766 853 805 1071 936 1038 1070 1090 N/A N/A N/A N/A N/A N/A N/A N/A

24.6 25.2 26.5 32 35 31.2 30 33.1 28.5 30.2 38.9 40.1 42.8 36.7 44.1 N/A N/A N/A N/A N/A N/A N/A N/A

0.35 0.19 0.21 0 0.22 0.00 0.13 0.13 0 0.12 0 0 0 0 0.09 N/A N/A N/A N/A N/A N/A N/A N/A

570 530 477 502 457 799 749 765 853 804 1071 936 1038 1070 1090 717 646 666 700 756 47 686 1022

13.3 3.8 4.9 4.1 4.2 3.5 7.4 9.9 11.9 8.9 2.7 2.1 3.2 2.7 9.7 1 0.6 1.1 1.7 0.6 0 2.4 12.8

0 0.19 0 0 0 0 0 0 0 0 0 0 0 0 0.09 0 0 0 8.19 0 0 1.03 0

571 530 478 503 457 799 749 765 853 804 1071 936 1038 1070 1089 717 646 674 714 756 47 696 1022

573.1 533.1 480 505 458.8 799.4 749.8 765.9 853.9 804.9 1071 936 1038 1070 1090 740.4 647.9 695.2 735.1 756.4 47 720.2 1022

21.1 21.3 21.5 21.6 21.4 79.3 80 78.3 81.1 79 197.3 200.9 207.8 211.6 212.3 238.9 240.6 235.8 241.8 241.9 6.6 239.2 214.3

1.3 1.5 1.2 1.7 0.9 0.5 0.4 0.3 0.5 0.4 0 0 0 0 0.4 9.7 3.2 8.3 9.4 1.3 0 10.2 0.4

0.18 0.19 0.21 0.2 0 0 0 0 0 0 0 0 0 0 0 0 0 1.2 10.36 0 0 2.5 0

16.53

0.45

30.29

0.19

33.26

0.10

4.9

0.41

138.9

0.64

The CPU time on a 1.0 GHz 2 Dual-Core AMD processor with 8.0 GB of RAM memory in C. The CPU time on a 2.1 GHz two Intel Core TM2 T8100 processor with 4.0 GB of RAM memory in C#. The CPU time on a 2.0 GHz Intel Core (TM) 2 Duo processor with 8.0 GB of RAM memory in C++. The CPU time on a 3.0 GHz AMD Athlon (TM) II× 4640 processor with 4.0 GB of RAM memory in C++.

obtain lower bound solutions in 22 instances; and IGA obtains lower bound solutions in 20 instances. A t-test shows that there is no significant difference between GA_OP and GA_ JS (t = 1.00 < t(0.05 , 22) = 2.07) and there is no significant difference between GA_OP and IGA (t = 1.31 < t(0.05 , 22) = 2.07). The three algorithms (GA_OP, GA_ JS) appear to perform equally well in solving 4-cell DFJS instances. Compared to Experiment 3, the 4-cell experiments proposed by Giovanni and Pezzella [11] is a lighter-load scheduling problem (i.e., the number of jobs to be scheduled is the same as that in Experiment 2, but the capacity is now increased by 2.0 times). Therefore, it is very likely that the three algorithms and some other heuristic algorithms can be used to obtain optimum solutions in the 4-cell experiments. For example, a heuristic algorithm proposed by Ziaee [38] may perform equally well as IGA in the 4-cell experiments, even though it is substantially inferior to IGA in the 2-cell experiments. Table 10 displays the results of Experiment 5. Of the n = 23 FJS instances, this table compares GA_OP against some outstanding methods [29,24,3] on solving FJSP problems. To the best of our knowledge, HA is the state-of-the-art algorithm in solving FJSP problems. Table 10 reveals that GA_OP performs almost equally well as that of HA in terms of solution quality. A t-test shows that there is no significant difference between GA_OP and HA (t = 1.97 < t(0.05 , 22) = 2.07). However, the computation time of GA_OP is substantially longer than that HA. The genetic parameter setting in Experiment 5 is exactly the same as that of Experiment 2 (Table 5). Notice that the computation time of GA_OP in solving an FJS problem (138.9 s. on average in Table 10) is much longer than that in solving 2-cell DFJS problem (37.5 s. on average in Table 7). This is due to that the number of operations in the critical cell of an FJS problem is about 2 times that of a 2-cell DFJS problem. Therefore, the computation time required for critical cell refinement in solving FJS problems (1-cell DFJS problem) is substantially increased. To provide a platform for researchers to compare other algorithms on solving DFJS problems, the input data, output data, and

the execution program of GA_OP and GA_ JS are accessible on the web site of http://wu002nctu.wordpress.com/. 8. Concluding remarks This paper addresses a scheduling problem called DFJS (distributed flexible job shop scheduling) problem, which is NP-hard in complexity. Several genetic algorithms (GAs) have been developed to solve the DFJS problems; these prior GAs are substantially different in using different chromosome representations. In a GA, a chromosome representation denotes the scheme used to model a solution. In this paper, we develop a new chromosome representation call SOP , and in turn develop a genetic algorithm (GA_OP) to solve the DFJS problems. The proposed GA_OP is compared against three prior genetic algorithms (IGA, GA_CL, and GA_ JS) developed for solving the DFJS problems. To the best of our knowledge, these three prior algorithms are the state-of-the-art methods in solving DFJS problems. To compare GA_OP against these prior algorithms, we carry out two experiments (Experiments 1 and 2) which include 31 DFJS instances in total. The experiment results reveal that GA_OP outperform these three benchmark algorithms in terms of solution quality. In addition, the computation time of GA_OP appears to be superior or at least competitive to the other algorithms. The contribution of this paper is two-fold. First, we develop an algorithm GA_OP which appears to outperform all prior algorithms in solving the DFJS problems. Second, we highlight the importance of developing an effective chromosome representation scheme while attempting to develop a meta-heuristic algorithm to solve a high-dimensional space search problem. Two extensions of this research are considered. First, the proposed GA_OP algorithm may be enhanced by developing various chromosome decoding algorithms. For example, we may develop various methods for the conversion from a Job-Cell-Op table to a Job-Cell table and test their effectiveness. In addition, we can

112

M.-C. Wu et al. / Computers and Operations Research 80 (2017) 101–112

apply various local search methods that have been developed in prior studies on FJS problems to possibly enhance the GA_OP algorithm. Second, we may address an extended DFJS problem by including the preventive maintenance (PM) scheduling in the original DFJS problems. As a result, this extended DFJS problems becomes more complex. Therefore, the proposed SOP chromosome representation has to be modified in order to additionally model the PM scheduling decision. Acknowledgement This research is finally supported by Ministry of Technology and Science in Taiwan under a research contract MOST 104-2221E-009-107-MY3. References [1] Bäck T, Schwefel HP. An overview of evolutionary algorithms for parameter optimization. Evolut Comput 1993;1(1):1–23. [2] Bierwirth C. A generalized permutation approach to job shop scheduling with genetic algorithms. Oper Res Spectr 1995;17(2-3):87–92. ˙ ´ [3] Bozejko W, Uchronski M, Wodecki M. Parallel hybrid metaheuristics for the flexible job shop problem. Comput Ind Eng 2010;59(2):323–33. [4] Brucker P, Schlie R. Job-shop scheduling with multi-purpose machines. Computing 1990;45(4):369–75. [5] Chan FTS, Chung SH, Chan PLY. An adaptive genetic algorithm with dominated genes for distributed scheduling problems. Expert Syst Appl 2005;29(2):364–71. [6] Chan FTS, Chung SH, Chan PLY. Application of genetic algorithms with dominant genes in a distributed scheduling problem in flexible manufacturing systems. Int J Prod Res 2006;44(3):523–43. [7] Chan FTS, Chung SH, Chan LY, Finke G, Tiwari MK. Solving distributed FMS scheduling problems subject to maintenance: genetic algorithms approach. Robot Comput-Integr Manuf 2006;22(5-6):493–504. [8] Chang HC, Liu TK. Optimisation of distributed manufacturing flexible job shop scheduling by using hybrid genetic algorithms. J Intell Manuf 2015:1–14. [9] Cheng R, Gen M, Tsujimura Y. A tutorial survey of job-shop scheduling problems using genetic algorithms—I. Representation. Comput Ind Eng 1996;30(4):983–97. [10] Cheng R, Gen M, Tsujimura Y. A tutorial survey of job-shop scheduling problems using genetic algorithms, part II: hybrid genetic search strategies. Comput Ind Eng 1999;36(2):343–64. [11] De Giovanni L, Pezzella F. An Improved Genetic Algorithm for the distributed and flexible job-shop scheduling problem. Eur J Oper Res 2010;200(2):395–408. [12] Demir Y, Kürs¸ at I˙ s¸ leyen S. Evaluation of mathematical models for flexible job-shop scheduling problems. Appl Math Model 2013;37(3):977–88. [13] Driss I, Mouss KN, Laggoun A. A new genetic algorithm for flexible job-shop scheduling problems. J Mech Sci Technol 2015;29(3):1273–81. [14] Gao J, Sun L, Gen M. A hybrid genetic and variable neighborhood descent algorithm for flexible job shop scheduling problems. Comput Oper Res 2008;35(9):2892–907. [15] Gao KZ, Suganthan PN, Pan QK, Chua TJ, Cai TX, Chong CS. Discrete harmony search algorithm for flexible job shop scheduling problem with multiple objectives. J Intell Manuf 2016;27(2):363–74.

[16] Gao KZ, Suganthan PN, Tasgetiren MF, Pan QK, Sun QQ. Effective ensembles of heuristics for scheduling flexible job shop problem with new job insertion. Comput Ind Eng 2015;90:107–17. [17] Garey MR, Johnson DS, Sethi R. The complexity of flowshop and jobshop scheduling. Math Oper Res 1976;1(2):117–29. [18] Genova K, Kirilov L, Guliashki V. A survey of solving approaches for multiple objective flexible job shop scheduling problems. Cybern Inf Technol 2015;15(2):3–22. [19] González MA, Vela CR, Varela R. Scatter search with path relinking for the flexible job shop scheduling problem. Eur J Oper Res 2015;245(1):35–45. [20] Gran SS, Ismail I, Ajol TA, Ibrahim AFA. Mixed integer programming model for flexible job-shop scheduling problem (FJSP) to minimize makespan and total machining time. In: IEEE 2015 international conference on computer, communications, and control technology (I4CT); 2015. p. 413–17. [21] Jia HZ, Fuh JYH, Nee AYC, Zhang YF. Web-based multi-functional scheduling system for a distributed manufacturing environment. Concurr Eng 2002;10(1):27–39. [22] Jia HZ, Nee AYC, Fuh JYH, Zhang YF. A modified genetic algorithm for distributed scheduling problems. J Intell Manuf 2003;14(3-4):351–62. [23] Jia HZ, Fuh JYH, Nee AYC, Zhang YF. Integration of genetic algorithm and Gantt chart for job shop scheduling in distributed manufacturing systems. Comput Ind Eng 2007;53(2):313–20. [24] Jia S, Hu ZH. Path-relinking Tabu search for the multi-objective flexible job shop scheduling problem. Comput Oper Res 2014;47:11–26. [25] Jones A, Rabelo LC, Sharawi AT. Survey of job shop scheduling techniques. Wiley encyclopedia of electrical and electronics engineering; 1999. p. 1–12. [26] Kaplanog˘ lu V. An object-oriented approach for multi-objective flexible job-shop scheduling problem. Exp Sys Appl 2016;45:71–84. [27] Kuhpfahl J, Bierwirth C. A study on local search neighborhoods for the job shop scheduling problem with total weighted tardiness objective. Comput Oper Res 2016;66:44–57. [28] Li JQ, Pan QK, Liang YC. An effective hybrid tabu search algorithm for multi-objective flexible job-shop scheduling problems. Comput Ind Eng 2010;59(4):647–62. [29] Li X, Gao L. An effective hybrid genetic algorithm and tabu search for flexible job shop scheduling problem. Int J Prod Econ 2016;174:93–110. [30] Lu PH, Wu MC, Tan H, Peng YH, Chen CF. A genetic algorithm embedded with a concise chromosome representation for distributed and flexible job-shop scheduling problems. J Intell Manuf 2015:1–16. [31] Mastrolilli M, Gambardella L. Effective neighborhood functions for the flexible job shop problem. J Sched 20 0 0;3(1):3–20. [32] Naderi B, Azab A. Modeling and heuristics for scheduling of distributed job shops. Exp Syst Appl 2014;41(17):7754–63. [33] Naderi B, Azab A. An improved model and novel simulated annealing for distributed job shop problems. Int J Adv Manuf Technol 2015;81(1-4):693–703. [34] Niu SH, Ong SK, Nee AYC. An improved intelligent water drops algorithm for solving multi-objective job shop scheduling. Eng Appl Artif Intell 2013;26(10):2431–42. [35] Nouiri M, Bekrar A, Jemai A, Niar S, Ammari AC. An effective and distributed particle swarm optimization algorithm for flexible job-shop scheduling problem. J Intell Manuf 2015:1–13. [36] Özgüven C, Yavuz Y, Özbakır L. Mixed integer goal programming models for the flexible job-shop scheduling problems with separable and non-separable sequence dependent setup times. Appl Math Model 2012;36(2):846–58. [37] Wang L, Zhou G, Xu Y, Wang S, Liu M. An effective artificial bee colony algorithm for the flexible job-shop scheduling problem. Int J Adv Manuf Technol 2012;60(1-4):303–15. [38] Ziaee M. A heuristic algorithm for the distributed and flexible job-shop scheduling problem. J Supercomput 2014;67(1):69–83.