Computers & Industrial Engineering 48 (2005) 491–506 www.elsevier.com/locate/dsw
Evolutionary algorithms for scheduling a flowshop manufacturing cell with sequence dependent family setups Paulo M. Franc¸aa, Jatinder N.D. Guptab,*, Alexandre S. Mendesd, Pablo Moscatod, Klaas J. Veltinkc a
Departamento de Engenharia de Sistemas, DENSIS Universidade Estadual de Campinas, UNICAMP C. P. 6101, 13081-970 Campinas, SP, Brazil b Department of Accounting and Information Systems, College of Administrative Science, The University of Alabama in Huntsville, Huntsville, AL 35899, USA c Department of Econometrics, University of Groningen Postbus 800, 9700 AV Groningen, The Netherlands d Department of Computer Science, School of Electrical Engineering and Computer Science, Faculty of Engineering and Built Environment, University of Newcastle Callaghan, 2308, NSW, Australia Received 1 April 2001; revised 1 November 2002; accepted 1 November 2003
Abstract This paper considers the problem of scheduling part families and jobs within each part family in a flowshop manufacturing cell with sequence dependent family setups times where it is desired to minimize the makespan while processing parts (jobs) in each family together. Two evolutionary algorithms—a Genetic Algorithm and a Memetic Algorithm with local search—are proposed and empirically evaluated as to their effectiveness in finding optimal permutation schedules. The proposed algorithms use a compact representation for the solution and a hierarchically structured population where the number of possible neighborhoods is limited by dividing the population into clusters. In comparison to a Multi-Start procedure, solutions obtained by the proposed evolutionary algorithms were very close to the lower bounds for all problem instances. Moreover, the comparison against the previous best algorithm, a heuristic named CMD, indicated a considerable performance improvement. q 2005 Elsevier Ltd. All rights reserved. Keywords: Flowshop scheduling; Family sequence dependent setups; Manufacturing cells; Group technology; Evolutionary algorithms; Empirical results
* Corresponding author. Tel.: C1 256 824 6593; fax: C1 256 824 2929. E-mail addresses:
[email protected] (J.N.D. Gupta),
[email protected] (A.S. Mendes),
[email protected]. edu.au (P. Moscato). 0360-8352/$ - see front matter q 2005 Elsevier Ltd. All rights reserved. doi:10.1016/j.cie.2003.11.004
492
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
1. Introduction Cellular manufacturing consists of processing a large number of parts on a given number of machines in such a way that it combines the flexibility of a job-shop while providing the efficiency offered by the flowshop production. It consists of grouping the machines (called manufacturing cells) and the parts into a specified number of part families where each part in a part family requires the same group of machines. In this environment, cellular manufacturing requires three planning activities before actual production can take place. First, the problem of grouping machines into various manufacturing cells (called cell formation) needs to be solved. This process also defines the part families where a part family is a set of parts (called jobs in this paper) that have similar requirements in terms of tooling, setups and operations sequences. Second, parts need to be assigned (loaded) to specified machines (called machine loading) in manufacturing cells. Third, the part families need to be scheduled in each of the manufacturing cells. Often, such scheduling problems consist of multiple manufacturing cells and may become rather complex. Therefore, attempts are made to develop a schedule by considering one manufacturing cell at a time. This paper deals with the scheduling problem of a single manufacturing cell assuming that the activities related to the cell formation and machine loading have been completed. In forming and loading the manufacturing cells, part families are assigned to a manufacturing cell based on operation sequences so that materials flow and scheduling are simplified even though the part families produced by a cell may require different tooling. This process may result in each part family requiring the same set of machines where each part is processed on each machine in the same technological order. Such manufacturing cells are called pure flowshop manufacturing cells and resemble the traditional flowshops except for the existence of multiple part families. Since parts are assigned to families based on tooling and setup requirements, usually a negligible or minor setup is needed to change from one part to another within a family and hence can be included in the processing times of each job. However, a major setup is needed to change processing jobs in one part family to another part family. This major family setup may be independent or dependent of the sequence in which various part families are processed. To reduce the productivity loss due to family setups, cellular manufacturing uses the concept of group technology (GT) where parts of the same family are processed together on the same set of machines. As manufacturers want to take advantage of group technology (GT) environment, scheduling of jobs grouped into families has become quite significant. Existing applications and scheduling techniques for such problems are discussed by Schaller, Gupta, and Vakharia (2000). Recent reviews of scheduling research involving separable setups by Allahverdi, Gupta, and Aldowaisan (1999) and Cheng, Gupta, and Wang (2000) showed that most prior research on manufacturing cell scheduling has assumed sequence independent setup times. For the flowshop manufacturing cell scheduling problem involving sequence dependent setup times, Hitomi, Nakamura, Yoshida, and Okuda (1977) described a simulation model and showed that the scheduling rules which considered explicitly sequence dependent setups outperformed rules that did not explicitly do so. Following Schaller et al. (2000) who developed and tested several heuristic algorithms for minimizing makespan in a flowshop with sequence dependent family setup times, this paper assumes that the major family setup times are sequence dependent. To formally define the above manufacturing cell scheduling problem in a group technology environment, consider that a given set of n jobs, NZ{1,2,.,n} is to be processed on m machines in the same technological order creating the flowshop structure. We assume that each job belongs to
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
493
one of K families. At each machine, there is changeover time from one family to another, called setup time. Assume that the processing time of job i at machine j is given by pij. Let the setup time for family f processed immediately after family r at machine j be sjrf where sjff Z 0 for all f. Further, let the jobs be numbered sequentially such that first n1 jobs belong to the first family, next n2 jobs and finally last nk jobs belongoto the belong to the second family, ., nf belong to the nPfamily f, . P PfK1 fK1 fK1 Kth family. Thus, nZn1C/Cnk. Let Nf ¼ repr¼1 nr þ 1; r¼1 nr þ 2;/; r¼1 nr þ nr resent the set of jobs belonging to family f2F and FZ{1,2,.,K} is the set of K families. Then, the completion time of job s(i) in a schedule sZ(s(1),.,s(n)) at machine j, C(s (i),j), is given by the following recursive relationship CðsðiÞ; jÞ Z maxfCðsðiÞ; j K 1Þ; Cðsði K 1Þ; jÞ C sjqf g C psðiÞ;j
(1)
where s(iK1)2Nq, s(i)2Nf, and C(f, j)ZC(s(i),0)Z0 for all i and j. Then, the manufacturing cell scheduling problem considered here is one of finding a schedule s that minimizes its makespan, C(s)ZC(s(n),m) where s ranges over all those permutations of n jobs in which all jobs of the same family are processed together. When each family contains only one job (i.e. nfZ1 for all f2F), the problem becomes a traditional flowshop with sequence dependent times which is NP-hard in the strong sense for mR2 (Gupta & Darrow, 1986). From this observation, it follows that the manufacturing cell scheduling problem considered here is NP-hard in the strong sense. In view of the NP-hard nature of the general flowshop problem, most researchers have focused on developing heuristic procedures which provide good permutation schedules (in which the order of job processing is the same on all machines) within a reasonable amount of computational time. However, there is no guarantee that a permutation schedule will be optimal when the shop contains four or more number of machines. This paper considers the problem of scheduling a pure (flowshop) manufacturing cell with sequence dependent family setup times and develops evolutionary algorithms to find minimum makespan permutation schedules. The proposed algorithms extend the existing local search algorithms for scheduling problems with and without setups and are quite effective in solving large-sized problems. While we illustrate the developments of the algorithms for the makespan criterion and the sequence dependent setup times, our proposed algorithms are quite general and can handle a variety of objective functions and setup configurations. The rest of the paper is organized as follows: Section 2 describes the solution representation and a Multiple Start algorithm. The evolutionary heuristic algorithms for obtaining approximate solutions to the problem are developed in Section 3. Results of computational tests to evaluate the performance of the proposed heuristic algorithms are reported in Section 4. Finally, Section 5 discusses the main results and describes some fruitful directions for future research.
2. Solution representation and an algorithm In this section, we first present a very condensed representation of the solution to a flowshop problem with family setup times and then describe a multi-start algorithm to find an approximate solution.
494
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
2.1. A compact solution representation The flowshop scheduling problem considered in this paper can be divided into two parts: the schedule of the families of jobs and the schedule of the jobs within the families. Therefore, a proper representation should take this division into account. Let dZ(d1,.,dK) be the order in which the families are scheduled on different machines. Further, let rfZ(rf(1),.,rf(nf)) be the order in which the jobs of family f are processed. Taking into account the two divisions described above, a schedule s for the flowshop with families is represented as sZ[djr1j.jrK]. As an illustration, consider the following problem instance with 12 jobs and four families. Family one consists of jobs 1–3; family two consists of jobs 4–7; family three of jobs 8 and 9; and family four consists of jobs 10–12. Suppose, we decide to process the jobs in family 1 first, followed by jobs in family 3, followed by family 4 and finally family 2. Jobs in family 1 are processed in the sequence (3, 1, 2); family 2 in the order (5, 7, 6, 4), family 3 in the sequence (8, 9) and finally family 4 in the order (11, 10, 12). Fig. 1 shows a condensed representation of this schedule for the problem instance considered above. Note that this representation divides the solution into KC1 independent parts. Therefore, local search, crossover, mutation and other chromosome-level operators can be executed separately within each part, without affecting the rest of the solution—which is reminiscent of the divide-and-conquer strategies. 2.2. A multi-start algorithm The Multi-Start (MS) algorithm implemented in this paper consists of sequentially generating an initial random solution followed by a hill-climbing procedure that uses two neighborhood definitions: all-pairs and insertion. The neighbors are obtained by systematically swapping all pairs of alleles in every given part of the sequence in the case of all-pairs; or by systematically removing each allele and inserting it in another position. Each time a swap or an insert move improves the solution, it is confirmed. Note that the swaps or insertions moves occur with alleles that belong to the same part of the solution. The search ends when no swap or insertion generates a better solution than the present. This process of generating an initial solution and making the trial moves is iterated many times until a stop criterion (a time-limit criterion has been used) is satisfied and then the best solution ever found is reported. It is one of the simplest methods and uses almost no adaptive procedure at all, with the exception of a good local search scheme. Despite this fact, MS implementations have shown good performance for scheduling problems and are often used as benchmarks (Glass & Potts, 1996; Aarts, Van Laarhoven, Lenstra, & Ulder, 1994). Summarizing the above discussion, the steps of the MS algorithm can be described as follows: Step 1. Create a random solution and enter Step 2. Step 2. Apply the local search on the random solution using either the all-pairs or the insertion neighborhoods and enter step 3.
Fig. 1. Solution representation.
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
495
Step 3. If the new solution is better than the incumbent solution, retain the better solution and enter step 4. Step 4. If the stopping criterion is satisfied, STOP; otherwise, return to step 1. The computational complexity of each neighborhood-all-pairs and insertion-is O(Ky2) where K is the number of families and yZmax1%f%Knf is the number of jobs in the largest family. As the exploration is done using both of them together, the computational effort required for this local search procedure is considerable.
3. Evolutionary algorithms In this section we briefly describe the Genetic and the Memetic Algorithms and discuss the manner in which they were implemented to solve the flowshop scheduling problem with family setups 3.1. The genetic algorithm The Genetic Algorithm (GA) is a population-based algorithm that uses analogies to natural, biological, and genetic concepts including chromosome, mutation, crossover, and natural selection. Basically, it consists of making a population of solutions evolve by mutation and reproduction processes. The best fitted solutions of the population shall survive while the worse fitted will be replaced. After a large number of generations, it is expected that the final population would be composed of highly adaptable individuals, or in an optimization application, high-quality solutions of the problem at hand. The basic steps of a canonical GA are as follows. Step 1. Initialize the population and enter step 2. Step 2. Select individuals for recombination and enter step 3. Step 3. Recombine individuals generating new ones and enter step 4. Step 4. Mutate the new individuals and enter step 5. Step 5. If the stopping criterion is satisfied, STOP; otherwise, replace old individuals with the new ones, restructure the population tree and return to step 2. In step 1, the initial population is created. In our work this population is composed of randomly generated solutions. Step 2 consists of selecting individuals among the population to recombine. This selection normally takes into account the fitness of the individuals or the quality of the solutions (regarding the objective function which in this case is the makespan). As our algorithm works with a hierarchically structured population, the selection is somewhat different (described in Section 3.3 below). In step 3, the selected individuals will recombine and generate new individuals. This means that new information is being added to the population. In this step, we used a variant of the Order Crossover (OX) strategy. In step 4, some individuals are submitted to a mutation process in order to preserve the diversity of the whole population. The mutation must be very light or important information can be lost. Finally, in step 5, the search stops if previously determined stopping criterion is satisfied. Otherwise, the new individuals generated in steps 3 and 4 replace some individuals of the population. Generally, the solutions to be replaced are chosen accordingly to their quality, and the worst fitted will give their place to the new ones. Once again, in our case, the replacement strategy is different due to the structured nature of our population (see Section 3.3 below).
496
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
3.2. The memetic algorithm In the case of a Memetic Algorithm (MA), after step 4 in the GA above, all new individuals go through a local search procedure before step 5. Details of MA are described in Moscato (1989) and Corne, Glover, and Dorigo (1999). The GA and the MA implementations are similar to previous work by Mendes, Muller, Franc¸a, and Moscato (1999). They share some main characteristics with the versions implemented for the single and parallel machine scheduling problems (Mendes et al., 1999) although some improvements have been introduced in this adaptation to the flowshop problem. The basic steps of the MA used here are as follows. Step 1. Initialize the population and enter step 2. Step 2. Select individuals for recombination and enter step 3. Step 3. Recombine individuals generating new ones and enter step 4. Step 4. Mutate the new individuals and enter step 5. Step 5. Apply the local search on the new individuals and enter step 6. Step 6. If the stopping criterion is satisfied, STOP; otherwise, replace old individuals with the new ones, restructure the population tree and return to step 2. 3.3. Implementation of evolutionary algorithms We now discuss the manner in which each aspect of the evolutionary algorithms was implemented for our problem and our reasons for choosing the specific parameters of the evolutionary algorithms. 3.3.1. Population structure GAs using structured population approaches are more common in implementations where the computational tests are executed on parallel computers (Gorges-Schleuter, 1997, Hart et al., 1996 and Radcliffe, 1994). Usually in this case, each processor is responsible for one individual or a set of them. Due to the use of a structured population, results obtained using parallel computers are in general much better than the ones obtained when a single-processor computer is used. Even though our computational implementation and tests have been obtained using a single-processor computer, we decided to implement a hierarchical population structure based on a complete ternary tree. In contrast with nonstructured designs, where all individuals can recombine with each other, the population is divided into clusters, thus restricting the number of possible pairs for recombination. The structure consists of several clusters, each one having a leader solution and three supporter solutions, as shown in Fig. 2. The leader of a cluster is dynamically updated during the run to have a better fitted solution than its three supporters. As a consequence, the top clusters tend to have better fitted individuals, on average, than the bottom clusters. As new individuals are continually generated (either by recombination, mutation or local search), replacing old ones, periodic adjustments are necessary to keep this structure well ordered. The number of individuals in the population is restricted to the numbers of nodes in a complete ternary tree, i.e. (3xK1)/2, where x is the number of levels of the tree. Thus, while 13 individuals are necessary to construct a ternary tree with 3 levels (as shown in Fig. 2 along with their fitness measures), 40 individuals are required to make one with four levels.
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
497
Fig. 2. Population structure with the corresponding population matrix.
3.3.2. Selection for recombination Recombination can only be made between a leader and one of its supporters within the same cluster. The selection procedure chooses a leader—and consequently the cluster—uniformly at random. We did not use any biased selection scheme—like the so-called roulette wheel procedures—since it did not improve the results. Then, the procedure chooses—also uniformly at random—one of the three supporters present in the same cluster selected before. There is no restriction to the number of recombinations an individual can take part in. A drawback in the random selection is that an individual might stay inert for several generations, without taking part in any recombination. Fortunately, this is an extremely rare situation. 3.3.3. Crossover operator The crossover operator we have chosen to implement is a variant of the well known order crossover (OX). After the two parents—a leader and one of its supporters—were selected through the procedure described before, the recombination itself starts. Considering the fact that the chromosome is divided into well-separated parts, the crossover also operates separately for each part. As an illustration of the crossover operators used here, consider the leader and supporter in Fig. 3 below. Initially, a fragment of the first part of the leader is chosen uniformly at random. Suppose the fragment is composed of the alleles 1–3. As shown in Fig. 4, this part is copied into the offspring at the same position, what gives us the initial configuration:
498
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
Fig. 3. An illustrative example of leader and supporter.
The rest of the first part of the offspring is completed according to the information of parent B, following the sequence of its alleles—from left to right. Therefore, at the end, we get the offspring fragment shown in Fig. 5. If we continue to do this procedure sequentially to the other parts of the chromosome, the final offspring would inherit important information from both parents, especially the relative order of the families and jobs. Fig. 6 shows a possible final offspring. In Fig. 6, we also marked up the alleles from the leader that were directly inherited and how the supporter completed the blank positions. The information that is transferred from the leader to the offspring is absolutely intact, that is, the leader contributes with the relative order and the absolute position of the alleles it transfers to the child. On the other hand, the supporter contributes only with the relative order. This scheme tends to generate a strong loss of diversity, and therefore, mutation operators are very important to avoid the premature convergence of the population. 3.3.4. Mutation strategies Mutation plays a major role in preserving the diversity of the population, especially if the recombination operator generates a fast diversity loss. In our algorithm, two types of mutation procedures were implemented: a light and a hard mutation procedure. The light mutation procedure initially chooses uniformly at random one of the parts of the chromosome. Then it chooses two alleles within this part, also randomly, and swaps their positions. If the part is composed of only one allele—for instance, a family composed of only one job—then nothing changes. This mutation is responsible for maintaining the diversity of the population for as long as possible, and since the change on the chromosome is very light, the probability of removing special features obtained during the evolutionary process is very low. The heavy mutation procedure executes q swap moves within each part, where q is the number of alleles in the specific part. As a result, once this heavy mutation procedure is applied over an individual, it will probably lose all its characteristics and would resemble a random solution at the end of the process. All evolutionary features of the individual are lost. The circumstances under which these mutations strategies are applied are discussed below. 3.3.5. Local search Local search algorithms rely on a neighborhood definition that establishes a relationship between solutions in the configuration space. In this work, two neighborhood definitions were adopted and they were both used in the Multi-Start and Memetic algorithms. One can define the neighborhood of a solution as the set of solutions that are reachable by executing any possible move allowed by the neighborhood generation scheme. One of the neighborhoods implemented was the all-pairs. It consists of all possible swaps of pairs of alleles within all parts of the solution. A hill-climbing algorithm can be
Fig. 4. An illustrative example of partial offspring fragment.
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
499
Fig. 5. An illustrative example of offspring fragment.
defined by reference to this neighborhood: starting with an initial permutation of families and jobs within each family, make sequential swaps within each part of the chromosome. A swap is confirmed every time it causes a reduction in the makespan. If the swap increases the makespan, the solution stays the same. After a successful swap, the cycle continues on the improved solution. After a complete check-out, if all possible swaps were executed in all parts of the chromosome and no improvement was obtained, the local search ends, otherwise, another cycle of swaps takes place on the improved solution. The second neighborhood implemented was the insertion neighborhood. It consists of removing an allele from one position and inserting it in another one within the same part of the chromosome. Jobs are removed and inserted sequentially starting from the left to the right. The hill-climbing procedure is the same as the all-pairs scheme. The MS and the MA use a hybrid neighborhood that consists of the swap and insertion neighborhoods put together in a tandem sequence. This gives a very strong search power for both algorithms and since the local search is executed within each part, separately, it was not necessary to implement neighborhood reduction or candidate list schemes. We could deal with solutions up to 70 alleles within a reasonable CPU time. 3.3.6. Insertion of new individuals In this work, we adopted the strict policy of only accepting new individuals if they improve the average fitness of the population. In practice, this means that any new solution with a makespan which is higher than both of its parents or is equal to one of them is automatically discarded. This said, a new individual can only replace the supporter that took part in the recombination if its makespan is smaller. At the end of each generation, the population is restructured to keep the hierarchical relation between individuals. Since the population is hierarchically structured and ordered, the makespan of any individual must be better than the makespan of all the individuals which form the sub-tree below it. The upper subgroups will have better individuals than the lower groups and the best solution will be the leader of the uppermost subgroup. The adjustment is done by comparing the leader of each subgroup with its supporters. If any supporter turns out to be better, they swap places. Any simple tree ordering algorithm can execute this job. The acceptance of individuals that only improve the average fitness generates a strong loss of diversity, but leads to a more constant rate of improvement of the incumbent solution—the best one ever found. Particularly important for the GA, this policy led to excellent results, making improvement rates much better than with the policy of always accept new individuals. The loss of diversity is compensated by the heavy mutation procedure, which is applied every time no new solution can be inserted into
Fig. 6. An illustrative example of complete offspring.
500
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
the population during a complete generation. This would show that the population has converged to individuals very close to each other in the configurations space. In such a situation, new improvements are very difficult to obtain and a heavy mutation executes the restart in the evolutionary process. The heavy mutation procedure is applied on all individuals except the best one, located at the root node of the ternary tree. 3.3.7. GA and MA parameters The evolutionary algorithms parameters were obtained after several tests. The hierarchically structured population and the size of the problems led to very similar performances of the evolutionary algorithms, independently of the size of the population, but the MA obtained slightly better results with fewer individuals. Therefore we used 13 individuals which correspond to a ternary tree with three levels. The crossover rate should be set at high levels, since our insertion policy works as a filter on the new individuals, accepting only those that improve the overall fitness. In our tests we tried crossover rates of 0.5, 0.75, 1, 1.25, 1.5, 1.75 and 2. In other words we tested situations where we created from 7 to 26 new individuals every generation. The best number was 20 individuals which corresponds to a crossover rate of 1.5. With less individuals being created every generation, we had heavy mutations procedures being applied too often. That occurred because it was very difficult to have a new individual replacing an old one after the population had already evolved for, say, 10 or 15 iterations. With 26 individuals being created, the number of generations executed during the 30-s time span dropped considerably, worsening the results. The mutation rate was set at 0.1 for the MA and 0.8 for the GA. That means 10% of the MA and 80% of the GA new individuals go through a light mutation process every generation. These numbers are not high, as they appear to be at first glance, since the light mutation changes only two alleles. Depending on the size of the instance, this is almost equivalent to a 0.5 or 1% per-bit mutation probabilities, commonly found in other works.
4. Computational results This section describes the computational tests which are used to evaluate the effectiveness and efficiency of the various heuristic methods in finding good quality schedules. For this purpose, we tested the following six heuristic algorithms. † † † † † †
MA1: Memetic Algorithm without population structure proposed in this paper. GA1: Genetic Algorithm without population structure proposed in this paper. CMD: The best algorithm in Schaller et al. (2000). MA2: Memetic Algorithm with population structure proposed in this paper. GA2: Genetic Algorithm with population structure proposed in this paper. MS: The Multi-Start Algorithm described in Section 2 of this paper.
All proposed algorithms were coded and run on a PC that has a PENTIUM-II 266 MHz processor, with 128 Mb RAM, using the Sun Java 2 JDK compiler. The results for the CMD algorithm were taken from the paper of Schaller et al. (2000) and through unpublished results available with one of the authors.
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
501
4.1. Test problems The test problems used in this paper are exactly the same utilized in Schaller et al. (2000) and are divided into three classes. In each class, processing times at each stage are random integers from a uniform distribution [1,10]. Problem hardness is likely to depend on whether there is a balance between average processing times and the average setup times. For this reason, three different classes of problems were used in the computational experiments. The setup times were random integers from the following uniform distributions in the following ranges: † class 1: Small setup times (SSU) [1,20]; † class 2: Medium setup times (MSU) [1,50]; † class 3: Large setup times (LSU) [1,100]. Note that a family set-up time distribution of U[1,20] implies that the ratio of mean family set-up time to mean job processing time is approximately 2:1 (10.5:5.5); a family set-up time distribution of U[1,50] implies that the ratio of mean family set-up time to mean job processing time is approximately 5:1 (25.5:5.5); and a family set-up time distribution of U[1,100] implies that the ratio of mean family set-up time to mean job processing time is approximately 10:1 (50.5:5.5). Problems were generated with number of families varying between 3 and 10, number of jobs in each family randomly generated between 1 and 10, and number of machines varying between 3 and 10. For each combination of problem parameters, 30 problem instances were generated. As an example of the notation, consider the LSU108 set of problems: it consists of 30 instances generated with setup times between 1 and 100, 10 families, 10 jobs per family at maximum and eight machines. Considering all configurations tested, we obtain a total of 900 problem instances. 4.2. Effectiveness of the heuristic methods Each problem instance was solved using each heuristic algorithm. In addition, for each problem, the lower bound on its optimal makespan was found using the branch and bound procedure described by Schaller et al. (2000). Using the output from these programs, percentage relative error rate (RER) for each heuristic algorithm h is computed as follows: RER Z ðMh K LBÞ !100=LB
(2)
where Mh is the makespan for the heuristic algorithm h and LB is the lower bound on the makespan for an optimal permutation sequence. 4.2.1. Heuristics without population structure The average, minimum, and maximum RER values for the three heuristic algorithms (MA1, GA1, and CMD) are shown in Table 1 below The CPU time is the average time for solving the 30 instances, keeping in mind that the algorithms always stops either when the lower bound is reached or when the running time becomes greater than 30 s. The ‘min’ labeled columns show, in subscript, the number of instances for which the algorithm makespan was equal to the corresponding lower bound. The results show that the best algorithm is the MA1, with average deviations always better than or equal to the other two methods. The percentage deviations for MA1 and GA1 are quite small, a clear
502
Table 1 Comparative evaluation of algorithms without population structure Instances
GA1
CMD
Min.
Ave.
Max.
CPU
Min.
Ave.
Max.
CPU
Min.
Ave.
Max.
CPU
0.0027 0.0020 0.0020 0.0018 0.009 0.0015 0.0015 0.006 0.110 0.001 0.0023 0.0017 0.0011 0.0015 0.006 0.0014 0.008 0.003 0.340 0.150 0.0023 0.0015 0.0015 0.004 0.003 0.006 0.001 0.280 0.860 0.590 0.08295
0.07 0.32 0.20 0.28 0.51 0.31 0.19 0.61 0.91 0.99 0.37 0.56 0.50 0.45 0.87 0.36 0.50 1.02 1.18 1.34 0.31 0.83 0.57 0.93 1.56 1.00 1.28 1.87 1.84 2.50 0.81
1.12 2.43 1.09 1.86 2.42 2.42 1.36 2.17 2.88 2.28 3.37 2.29 2.32 2.09 3.12 1.22 1.63 2.98 3.02 3.22 2.47 2.94 2.90 2.34 3.08 3.44 2.72 3.57 2.91 4.08 2.52
3.1 10.1 10.1 12.2 21.2 15.2 15.4 25.5 31.0 30.7 7.0 13.1 19.1 15.1 24.1 16.7 22.6 28.0 30.7 31.0 7.1 15.0 15.1 26.0 27.4 24.2 29.1 30.4 30.9 30.8 20.6
0.0027 0.0020 0.0020 0.0017 0.009 0.0011 0.008 0.003 0.210 0.340 0.0023 0.0017 0.008 0.0015 0.004 0.008 0.004 0.001 0.600 0.910 0.0022 0.0014 0.0014 0.002 0.001 0.004 0.700 0.280 0.860 2.680 0.22252
0.07 0.32 0.20 0.30 0.55 0.47 0.63 1.83 3.79 3.81 0.37 0.56 0.59 0.50 0.94 0.75 0.71 2.41 3.59 4.25 0.34 0.85 0.71 1.35 2.16 1.23 2.12 3.84 4.00 5.18 1.61
1.12 2.43 1.09 1.86 2.42 2.42 3.70 8.41 9.75 7.53 3.37 2.29 2.32 2.09 3.12 3.24 1.74 5.53 9.00 8.37 2.47 2.94 4.65 2.92 4.58 3.44 4.00 7.63 5.83 9.16 4.31
3.0 10.3 10.6 13.5 21.8 20.3 24.6 28.0 30.0 30.0 6.7 13.1 22.2 15.6 26.3 23.8 27.0 29.2 30.0 30.0 8.1 16.7 16.9 28.1 29.1 26.8 30.0 30.0 30.0 30.1 22.1
0.0021 0.0012 0.008 0.004 0.004 0.003 0.003 0.280 0.120 0.530 0.0021 0.0011 0.004 0.004 0.001 0.003 0.001 0.630 2.890 2.290 0.0018 0.008 0.008 0.001 0.001 0.002 1.240 3.200 2.580 4.070 0.59138
0.91 1.08 1.95 2.49 3.37 3.29 3.03 6.25 6.22 6.30 0.92 2.00 1.96 3.10 3.58 3.68 4.59 5.68 6.11 5.73 0.67 1.85 1.94 3.15 4.02 3.00 4.06 5.62 5.63 6.86 3.63
8.41 16.39 10.27 9.57 17.07 10.02 10.47 18.17 11.25 11.42 11.46 16.28 11.11 8.48 13.13 8.88 15.77 12.68 10.83 9.92 4.13 8.46 8.33 6.61 8.93 6.90 9.16 8.59 8.96 9.11 10.69
0.04 0.06 0.12 0.21 0.26 0.3 0.44 0.95 1.82 2.37 0.04 0.05 0.13 0.19 0.27 0.30 0.40 0.97 1.84 2.37 0.04 0.05 0.12 0.20 0.25 0.32 0.44 0.91 1.82 2.21 0.64
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
LSU33 LSU34 LSU44 LSU55 LSU56 LSU65 LSU66 LSU88 LSU108 LSU1010 MSU33 MSU34 MSU44 MSU55 MSU56 MSU65 MSU66 MSU88 MSU108 MSU1010 SSU33 SSU34 SSU44 SSU55 SSU56 SSU65 SSU66 SSU88 SSU108 SSU1010 Average
MA1
Table 2 Comparative evaluation of algorithms with population structure Instances
GA2
MS
Min.
Ave.
Max.
CPU
Min.
Ave.
Max.
CPU
Min.
Ave.
Max.
CPU
0.0027 0.0020 0.0020 0.0018 0.009 0.0015 0.0015 0.006 0.001 0.001 0.0023 0.0017 0.0011 0.0015 0.006 0.0014 0.008 0.003 0.001 0.150 0.0023 0.0015 0.0015 0.004 0.003 0.006 0.001 0.280 0.720 0.590 0.06297
0.07 0.32 0.20 0.28 0.51 0.31 0.19 0.58 0.47 0.77 0.37 0.56 0.50 0.45 0.87 0.36 0.50 0.99 0.86 1.15 0.31 0.83 0.57 0.92 1.56 0.99 1.28 1.85 1.77 2.33 0.76
1.12 2.43 1.09 1.86 2.42 2.42 1.36 1.86 1.19 2.27 3.37 2.29 2.32 2.09 3.12 1.22 1.63 2.98 1.80 2.53 2.47 2.94 2.90 2.34 3.08 3.44 2.72 3.31 2.90 3.65 2.37
3.1 10.1 10.1 12.1 21.1 15.1 15.3 24.7 29.8 29.5 7.1 13.1 19.1 15.1 24.1 16.2 22.7 27.3 30.1 30.8 7.1 15.1 15.0 26.0 27.4 24.0 29.1 30.3 30.7 30.6 20.4
0.0027 0.0020 0.0020 0.0018 0.009 0.0015 0.0015 0.006 0.001 0.002 0.0023 0.0017 0.0011 0.0015 0.006 0.0013 0.007 0.002 0.160 0.150 0.0023 0.0015 0.0015 0.004 0.003 0.006 0.001 0.280 0.720 0.990 0.08294
0.07 0.32 0.20 0.28 0.51 0.31 0.19 0.60 0.73 0.86 0.37 0.56 0.50 0.45 0.87 0.39 0.51 1.03 1.11 1.37 0.31 0.83 0.57 0.95 1.61 1.02 1.28 1.95 1.92 2.80 0.81
1.12 2.43 1.09 1.86 2.42 2.42 1.36 2.01 3.34 2.81 3.37 2.29 2.32 2.09 3.12 1.47 1.63 2.98 2.60 3.22 2.47 2.94 2.90 2.34 3.08 3.44 2.72 3.81 3.17 4.14 2.56
3.0 10.0 10.1 12.0 21.0 15.2 15.8 24.5 29.4 28.8 7.0 13.0 19.0 15.1 24.2 18.0 23.2 28.1 30.2 30.1 7.1 15.4 15.0 26.0 27.1 24.0 29.0 30.1 30.1 30.1 20.4
0.0027 0.0020 0.0020 0.0018 0.009 0.0015 0.0015 0.006 0.110 0.001 0.0023 0.0017 0.0011 0.0015 0.006 0.0013 0.007 0.002 0.001 0.180 0.0023 0.0015 0.0015 0.004 0.003 0.006 0.001 0.280 0.860 0.900 0.08293
0.07 0.32 0.20 0.28 0.51 0.31 0.19 0.60 0.62 0.88 0.37 0.56 0.50 0.45 0.87 0.40 0.51 1.02 1.21 1.35 0.31 0.83 0.59 0.95 1.57 1.03 1.29 1.93 2.06 2.75 0.82
1.12 2.43 1.09 1.86 2.42 2.42 1.36 2.01 1.49 2.25 3.37 2.29 2.32 2.09 3.12 1.47 1.63 2.98 2.45 3.06 2.47 2.94 2.90 2.48 3.08 3.44 2.72 3.45 3.37 4.30 2.47
3.1 10.2 10.2 12.3 21.2 15.6 16.0 25.4 31.4 30.6 7.1 13.1 19.1 15.2 24.3 17.5 23.5 28.8 30.7 31.6 7.1 15.2 15.3 26.2 27.5 24.3 29.4 30.5 31.2 30.1 20.8
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
LSU33 LSU34 LSU44 LSU55 LSU56 LSU65 LSU66 LSU88 LSU108 LSU1010 MSU33 MSU34 MSU44 MSU55 MSU56 MSU65 MSU66 MSU88 MSU108 MSU1010 SSU33 SSU34 SSU44 SSU55 SSU56 SSU65 SSU66 SSU88 SSU108 SSU1010 Average
MA2
503
504
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
indication of the quality of both the lower bound and the methods implemented. This situation is confirmed by the ‘min’ labelled columns with several zero elements and by the number of times the algorithms have reached the lower bounds. The results in Table 1 also show that the proposed basic algorithms, MA1 and GA1, outperform algorithm CMD, which was found to be the best algorithm by Schaller et al. (2000). Algorithm MA1 results in schedules with lower makespan than algorithm GA1, indicating the effectiveness of using local search techniques, described in Section 3 of this paper. These results are consistent with those obtained in previous works with other problems where the GA strategies generally performed much worse than the MA and the MS. 4.2.2. Effectiveness of population structure Table 2 shows the average, minimum, and maximum RER values for the three heuristic algorithms (MA2, GA2, and MS) The ‘min’ labeled columns show, in subscript, the number of instances for which the algorithm makespan was equal to the corresponding lower bound. A comparison of results in Tables 1 and 2 show that algorithms MA2 and GA2 outperform algorithms MA1 and GA1, respectively. While the use of population structures proposed in this paper improved the performance of MA2 and GA2, it is clear that the improvement is more pronounced in GA2 than MA2. We believe this occurred due to the fact that the local search neighborhoods were enormous in relative comparison, giving an advantage in the search power to those methods in such a way the GA1 could not be competitive. The performance relation in this work has changed dramatically, and the GA2 obtained results very close to MA2. Analyzing this fact separately, we believe the main reason for this improvement in the performance is the scheme to only accept individuals that improve the average fitness of the population. A review of results in Tables 1 and 2 also shows that even the simple Multi-Start (MS) algorithm outperforms the CMD algorithm, the best existing heuristic to solve our problem. Therefore, our computational results show that the proposed evolutionary and MS algorithms are quite effective in minimizing makespan for the flowshop problem with sequence dependent setup times.
5. Conclusions This paper proposed evolutionary heuristic algorithms to minimize makespan in a pure flowshop manufacturing cell problem with sequence dependent setup times between families of jobs. The heuristic algorithms implemented are a Memetic Algorithm (MA), a Genetic Algorithm (GA) and a Multi-Start (MS) strategy. Computational results show that the proposed algorithms are relatively more effective in minimizing makespan than the best known heuristic algorithm. The performance of the three proposed heuristic algorithms was very similar, with a slight superiority demonstrated by the memetic implementation. The average deviations from the lower bound were always less than 3%, showing that the lower bound has good quality and the heuristics are very efficient. The number of optimal solutions found is also considerable. The evolutionary approaches use a hierarchically structured population and the local search adopted in the MA and in the MS uses two O(Ky2) neighborhood definitions: all-pairs and insertion (where y is the maximum number of jobs in any one family). Given the characteristics of the problem and the chosen representation, the computational time spent in the local search is very reasonable, even for the largest
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
505
instances, and no neighborhood reduction schemes were needed. Use of these specialized population structures in the evolutionary algorithms (MA and GA) further improved these results. Another important difference in the evolutionary algorithms is the decision to accept new individuals. In this work we used a policy of only accepting new individuals if they improve the average fitness of the population. This implies a reduction of diversity, with the population converging prematurely. To counterbalance this, we used two mutation procedures, that added diversity to the population in a very efficient way: the light mutation is responsible for maintaining the diversity of the population as long as possible without losing the advantages the special features obtained during the evolutionary process. The heavy mutation, on the other way, makes a restart in the population after all individuals have converged to very similar configurations. In this mutation procedure, all evolutionary features of the individuals are lost, except for the best individual, which is preserved. While we presented the proposed algorithms for the flowshop manufacturing cells scheduling problem with sequence dependent family setup times to minimize makespan, they can also be used to solve problems involving different objective functions and setup time configurations. Since the solution representation and the search strategies are quite generic, they are directly applicable to various types of problems. The development of various heuristic algorithms in this paper also results in some fruitful directions for future research. First, the proposed algorithms can also be used to solve problems involving some precedence constraints and resource restrictions. As the search progresses, it should be possible to check the feasibility conditions with respect to the precedence constraints and resource restrictions before swaps are made and offsprings are generated. Second, several improvements are possible that will enhance the quality of the solution obtained by the proposed algorithms. One possible improvement may well be to create a hybrid algorithm that uses an algorithm like the CMD as the initial seed. Third, as stated earlier, the proposed algorithms can be adapted to solve the sequence dependent flowline problems with other objective functions, like the minimization of the total flow time. Finally, the proposed algorithm can be adapted to solve more complex problems like the multi-stage scheduling problems with setups where each stage contains multiple machines. Thus, more research is necessary in the area of scheduling with setups.
Acknowledgements This work was supported by Fundac¸a˜o de Amparo a` Pesquisa do Estado de Sa˜o Paulo (FAPESP), Brazil. Constructive comments from two anonymous reviewers and the special issue guest editor, Gu¨rsel A. Suer, improved the quality of the paper.
References Allahverdi, A., Gupta, J. N. D., & Aldowaisan, T. (1999). A survey of scheduling research involving setup considerations, OMEGA. International Journal of Management Science, 27, 219–239. Aarts, E. H. L., Van Laarhoven, P. J. M., Lenstra, J. K., & Ulder, N. L. J. (1994). A computational study of local search algorithms for job shop scheduling. ORSA Journal on Computing, 6, 118–125.
506
P.M. Franc¸a et al. / Computers & Industrial Engineering 48 (2005) 491–506
Cheng, T. C. E., Gupta, J. N. D., & Wang, G. (2000). A review of flowshop scheduling research with setup times. Production and Operations Management, 9, 283–302. Corne, D., Glover, F., & Dorigo, M. (1999). New ideas in optimisation. New York: McGraw-Hill. Glass, C. A., & Potts, C. N. (1996). A comparison of local search methods for flow shop scheduling. Annals of Operations Research, 63, 489–509. Gorges-Schleuter, M. (1997). Asparagos96 and the traveling salesman problem. Proceedings of 1997 IEEE international conference on evolutionary computation—ICEC’97, Indianapolis, USA (pp. 171–174). Gupta, J. N. D., & Darrow, W. P. (1986). The two-machine sequence dependent flowshop scheduling problem. European Journal of Operational Research, 24, 439–446. Hart, W. E., Baden, S., Belew, R. K, & Kohn, S. (1996). Analysis of the numerical effects of parallelism on a parallel genetic algorithm. Proceedings of 10th international parallel processing symposium—IPPS’96, Honolulu, USA (pp. 606–612). Hitomi, K., Nakamura, N., Yoshida, T., & Okuda, K. (1977). An experimental investigation of group production scheduling. Proceedings of the fourth international conference on production research, Tokyo , 608–617. Mendes, A. S., Muller, F. M., Franc¸a, P. M., & Moscato, P. (1999). Comparing meta-heuristic approaches for parallel machine scheduling problems with sequence-dependent setup times. Proceedings of the 15th international conference on CAD/CAM ` guas de Lindo`ia, SP, Brazil. robotics and factories of the future, A Moscato, P. (1989). On evolution, search, optimization, genetic algorithms and martial arts: towards memetic algorithms. Caltech Concurrent Computation Program, C3P Report 1989 826. Radcliffe, N. J. (1994). Formal memetic algorithms. In T. C. Fogarthy (Ed.), Evolutionary computing: AISB workshop (pp. 1–16). New York: Springer, 1–16. Schaller, J. E., Gupta, J. N. D., & Vakharia, A. J. (2000). Scheduling a flowline manufacturing cell with sequence dependent family setup times. European Journal of Operations Research, 125, 324–339.
