Next Article in Journal
Stability of the Equation of q-Wright Affine Functions in Non-Archimedean (n,β)-Banach Spaces
Next Article in Special Issue
Quasi-Reflective Chaotic Mutant Whale Swarm Optimization Fused with Operators of Fish Aggregating Device
Previous Article in Journal
Frequency Up-Conversion for Vibration Energy Harvesting: A Review
Previous Article in Special Issue
An Evolutionary Numerical Method of Supply Chain Trust Networks with the Degree of Distribution
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Automatic Design of Efficient Heuristics for Two-Stage Hybrid Flow Shop Scheduling

1
Academy for Advanced Interdisciplinary Studies, Peking University, Beijing 100871, China
2
Department of Industrial & Systems Engineering, University of Wisconsin-Madison, Madison, WI 53706, USA
*
Author to whom correspondence should be addressed.
Symmetry 2022, 14(4), 632; https://doi.org/10.3390/sym14040632
Submission received: 7 March 2022 / Revised: 17 March 2022 / Accepted: 17 March 2022 / Published: 22 March 2022
(This article belongs to the Special Issue Meta-Heuristics for Manufacturing Systems Optimization)

Abstract

:
This paper addresses the two-stage hybrid flow shop scheduling problem with a batch processor in the first stage and a discrete processor in the second stage. Incompatible job families and limited buffer size are considered. This hybrid flow shop configuration commonly appears in manufacturing operations and the batch processor is always the bottleneck which breaks the symmetry of processing time. Since making a real-time high-quality schedule is challenging, we focus on the automatic design of efficient heuristics for this two-stage problem based on the genetic programming method. We develop a hyper-heuristic approach to automate the tedious trial-and-error design process of heuristics. The goal is to generate efficient dispatching rules for identifying complete schedules to minimize the total completion time. A genetic programming with cooperative co-evolution approach is proposed to evolve the schedule policy automatically. Numerical results demonstrate that the proposed approach outperforms both the constructive heuristic and meta-heuristic algorithms, and is capable of producing high-quality schedules within seconds.

1. Introduction

Most studies on job scheduling problems have addressed manufacturing systems that only consist of various discrete processors. However, there are many existing manufacturing systems that are comprised of both a discrete processor and a batch processor, where the batch processor can process several jobs simultaneously. This can be seen in many industries, such as the semiconductor industry, the aerospace industry, the auto-mobile industry, the steel industry, and the ceramics industry. For example, semiconductor manufacturing involves numerous batch processing operations such as diffusion, etching and burn-in operation of devices, followed by many non-batching operations such as planarization and ion implantation.
In these manufacturing systems, the batch processor is always the bottleneck due to its expensive and time-consuming characteristics [1], which break the processing time symmetry of successive operations of a flow shop. Identifying effective production schedules can be quite beneficial for such systems.
However, owing to the distinguishing characteristic of the batch processor and the cooperation with the discrete processor, making a production schedule of this system should address at least three aspects, namely, the batch formation, batch sequencing and job sequencing of the discrete processor. Multiple decision points significantly increase the complexity of the decision-making logic. Hence, an efficient and effective scheduling algorithm is urged to help with better decision-making.
In this paper, we investigate a two-stage hybrid flow shop scheduling problem with a batch processor and a uni-capacity discrete processor in the first and second stage, respectively. This configuration is derived from an aerospace equipment manufacturer, but is a general production unit of many complex manufacturing environments.
A size-limited buffer (LB) is considered between two processors; this is more practical because many factories have limited space in their manufacturing room and minimal storage space. We also consider the incompatible job families (IF), which disallow jobs from the different job families to be formed into a batch because of different chemical or temperature requirements or other technique parameters. The objective is to minimize the total completion time. We denote this problem as β δ | L B , I F | C i based on the three-field notation of [2], where β and δ denote a batch processor and a discrete processor, respectively, and → represents the sequence of processors. This paper studies exactly the same problem as [3], but proposes a more effective and efficient algorithm which solves the original problem better and is capable of solving large scale problems for real-time scheduling.
Since the β δ | L B , I F | C i problem reduces to the β δ | C i problem, which is shown to be NP-complete [4], the problem studied in this paper is also NP-complete and exact methods are hardly able to solve the problem with large instances in a reasonable time. This usually leads to the development of heuristics, which can provide not necessarily optimal but practical acceptable solutions in a short time. However, the design of a heuristic could be a tedious trial-and-error process and the manually designed heuristic may become no longer efficient when a problem changes, e.g., the shortest processing time (SPT) rule is efficient for the criterion of C m a x but less efficient for T m a x . Fortunately, this process can be automated by a hyper-heuristic which is an optimization method searching on the space of heuristic.
Genetic Programming (GP) is one of the most prevalent approaches in the domain of evolutionary computing. Although it was initially proposed for searching optimal small computer programs, many recent studies have demonstrated that GP is highly suitable for automatically evolving heuristics in the form of the dispatching rule [5].
Motivated by these, this paper aims to develop a GP-based hyper-heuristic to automate the process of designing reusable dispatching rules, which can be applied for solving new problem instances once they are generated, for solving the problem of β δ | L B , I F | C i .
The main contributions of this paper are summarized as follows:
  • We formally formulate and decompose the β δ | L B , I F | C i problem into three parts, and design an efficient greedy dealing dispatching rules (GDDR) heuristic of which the time complexity is O ( n 2 ) .
  • On the basis of GDDR, we firstly design a cooperative co-evolutionary genetic programming (GDDR-CCGP) to characterize different decision points of the problem with three sub-populations, and generate dispatching rules for each decision point while simultaneously exploring the synergistic relationship between dispatching rules by adopting the proposed two-trial evaluation scheme.
  • Numerical results demonstrate that the proposed GDDR-CCGP algorithm significantly outperforms the state-of-the-art meta-heuristic algorithms in terms of both solution quality and efficiency.
  • We also discuss the importance of three decision points of the two-stage hybrid flow shop scheduling problem, which provides new insights for the design of dispatching rules.
The problem studied in this paper originated from an aerospace equipment manufacturer, where heat-treatment is one of the most important bottleneck operations. Our proposed algorithm can be applied to manufacturers suffering from the bottleneck of batch processing operations such as gear manufacture and semiconductor manufacture. The complete scheduling policy generated by the proposed GDDR-CCGP algorithm can be embedded into the ERP or APS system of manufacturing enterprises to directly guide production. High-quality dispatching rule based scheduling policies can quickly respond to complex dynamic changes of production environment by enabling real-time online decision-making. Moreover, managers can learn useful knowledge from the dispatching rules generated by our algorithm and incorporate the knowledge into manually designed heuristics, i.e., learn from machine learning.
The rest of this paper is organized as follows. A literature review is conducted in Section 2. Section 3 introduces the description and mathematics model of the problem. In Section 4, the greedy dealing dispatching rules (GDDR) heuristic scheme is proposed. In Section 5, we develop a cooperative co-evolution genetic programming based hyper-heuristic to generate dispatching rule combinations which are utilized by the GDDR heuristic. Computational experiments are conducted in Section 6. Variants of the proposed hyper-heuristic are compared and discussed in Section 7. Finally, we provide our conclusions and future works in Section 8.

2. Literature Review

In this section, we conduct a literature review from two perspectives. One perspective is the existing research on the two-stage hybrid flow-shop scheduling problem. The other perspective is the related works about applying GP to generate a production schedule policy.
Ahmadi et al. [4] studied two-stage hybrid flow-shop scheduling problems with variants of configurations including β δ , δ β and β 1 β 2 , where both objectives of C m a x and C i were considered. In the context of β δ | C i , they proposed a Full Batch-Dealing-SPT Policy to find near optimal schedules. However, their research assumed an identical family and an infinite buffer size. In addition, Su et al. [6] considered the size-limited buffer into the β δ problem, and proposed a heuristic to solve the problem of β δ | C m a x , thus, a branch-and-bound algorithm was developed as a benchmark. Computational results showed that the heuristic can provide high quality solutions for large instances up to 400 jobs. In their research, processing times of the batching operations were considered as identical. Afterwards, Fu et al. [7] considered both incompatible families and size-limited buffer in the problem of β δ | C ¯ , where buffer size h was equal to the physical capacity of batch processor b. They proposed a differential evolution-based algorithm for the batch sequencing phase, the full batch dealing policy of [4] and the first-in-first-out rule were applied in the batch formation phase and job sequencing phase, respectively. In addition, two heuristic algorithms and a lower bound were developed for performance evaluation. Shi et al. [8] considered the same problem with a larger buffer and proposed a greedy shortest processing time heuristic algorithm. Zhang et al. [3] extended the work of [8] and developed a recycled differential evolution approach (RDE) for the batch sequencing phase. A composite lower bound was proposed to evaluate the efficiency of RDE, and results showed that, in almost all instances, RDE performs significantly better than the differential evolution-based algorithm proposed by [7]. However, RDE requires much more time for large-scale problem instances. Mauluddin [9] addressed a three-stage flow shop scheduling problem of δ β δ | C i , they developed a mixed integer linear programming model with analysis, but algorithms were not yet proposed.
Hyper-heuristic is essentially a search methodology upon the space of heuristic, it selects or generates a heuristic for computational search problems rather than solving problems directly. In this sense, a hyper-heuristic usually incorporates a meta-heuristic or learning strategy to enhance the generation or selection efficiency during the searching process. For example, genetic algorithm [10,11] and tabu search [12] have been applied for searching a heuristic. A well-designed hyper-heuristic can yield more reusable and generally applicable heuristics than many meta-heuristics, such hyper-heuristics have been successfully applied to many problem domains, such as production scheduling, cutting and packing [13], vehicle routing [14] and timetabling [15]. The most recent and comprehensive review related to hyper-heuristics can be found in [5]. In this paper, we employ the genetic programming as a hyper-heuristic to generate dispatching rules for production scheduling problems.
In the context of GP, most work discussed in this paper was based on [16] and employed the expression tree representation. Miyashita et al. [17] employed GP to evolve dispatching rules for the first time, they evolved dispatching rules for two predetermined classes (bottlenecks and non-bottlenecks) of machines separately. Then, Dimopoulos and Zalzala [18] investigated a single machine total tardiness problem and experiment results showed that the GP-generated heuristic is superior to three manually designed heuristics. In addition, Geiger et al. [19] developed a scheduling rule discovery and parallel learning system to evolve dispatching rules for a variety of single machine problems. It has been shown that the proposed approach can evolve competitive or better dispatching rules than benchmark rules. They also extended their work to a two-machine flow shop problem, where they simultaneously evolved dispatching rules for each machine. As a result, two separate dispatching rules composed a scheduling policy. By employing the same approach, Geiger and Uzsoy [20] evolved dispatching rules for the single batch processor problem with incompatible job families. Instead of evolving dispatching rules for the batch formation phase and batch sequencing phase separately, they dealt with the two phases with a single dispatching rule. Hildebrandt et al. [21] studied a complex dynamic job shop scheduling problem with the objective function of minimizing cycle time. They evolved a unique sequencing rule to use on every machine and results showed that the rule evolved by GP outperformed the manually designed rules. However, the batch formation rule was not considered. Most recently, Shi et al. [22] proposed a ranking-and-selection-based genetic programming for the dynamic job shop scheduling problem. They formulated the evaluation problem as a ranking and selection problem and proposed a novel evaluation strategy to enhance the search efficiency of GP. A comprehensive review of GP can be found in [23].
In terms of applying GP to problems with multiple decision points, related works are rare. Park et al. [24] studied the order acceptance and scheduling problem, they proposed five GPs, in which dual genetic programming was included. The dual genetic programming consists of two specialized GPs to handle the order acceptance decision and the job sequencing decision separately. However, it performs the worst among the five GPs, which suggests that there is neither significant advantage nor necessity to separate the training of the two decision points. Nguyen et al. [25] proposed a diversified multi-objective cooperative co-evolution (DMOCC) to evolve scheduling policies for the dynamic multi-objective job shop scheduling problem. The DMOCC comprises two GPs, one for evolving due date assignment rules and the other evolves job sequencing rules. They showed that DMOCC performs better than other search strategies in their research. Yska et al. [26] investigated the dynamic flexible job shop scheduling problem by adopting the genetic programming with cooperative co-evolution. They co-evolved the routing rule and sequencing rule simultaneously. Experiment results showed that the proposed algorithm could evolve promising schedule policies that performed much better than the GP only sequencing rule with a fixed routing rule.
To the best of our knowledge, there is no existing research simultaneously evolving heuristics for both the batch processor and single capacity processor, as well as the problem of β δ | L B , I F | C i .

3. Problem Description

In this section, some notations are introduced and the two-stage hybrid flow shop scheduling problem of β δ | L B , I F | C i is described.
Figure 1 describes the manufacturing configuration of the problem we studied. In our problem, there are n jobs belonging to m job families. All jobs are of the same size and each job only occupies one capacity unit of the batch or the buffer. Each batch of family k can only contain up to b jobs from the same family k and has a family dependent batch processing time q k . Following the full batch property proposed by [27], we assume that the number of jobs of each family, as well as the buffer size, is an integral multiple of batch capacity. This assumption is also based on the reality that, as the batch processor is always the bottleneck, there are enough jobs for full batches of a family and schedulers are trying to make full batches as possible as they can. Whenever a job needs to be processed, it goes through the batch and discrete processors sequentially. Before a job is processed by the batch processor, it has to be formed into a batch, then the batch is processed by the batch processor. After that, if the empty space of the buffer is greater than batch capacity b, the batch is released to the buffer; otherwise, the batch is blocked in the batch processor until there is enough buffer space for it. The job can be processed by the discrete processor in arbitrary sequence without preemption. The goal is to find a complete schedule which consists of batch formation, batch sequencing and job sequencing decisions, to minimize the total completion time of all jobs. Based on the description, the decision variables and problem formulation are given below.
Constraint (1) defines the objective function of minimizing total completion time. Constraints (2) and (3) guarantee a job can be assigned to only one batch and a batch can handle up to b jobs. Constraints (4) and (5) ensure a batch belongs to only one job family and the number of jobs of a family is an integral multiple of the batch capacity. The constraint of incompatible job family is captured by Constraint (6). Constraints (7) and (8) restrict the start time and release time of a batch to ensure that it is reasonable. Constraint (9) denotes the batch processing time. Constraints (10)–(13) disallow a batch to be released from the batch processor until there are at least b spaces in the buffer. Constraints (14) and (15) ensure that jobs can be processed by the discrete processor only when it has been released from the batch processor and all jobs in front of it are completed. Constraints (16)–(19) define the range of decision variables. During our preliminary experiments, only small instances of this model can be solved by the CPLEX 12.6.3 within one hour, we do not report these results in this paper. In the rest of this paper, we aim to propose a genetic programming-based hyper-heuristic for automatically generating a heuristic to solve this problem efficiently.
min j N C j
s . t . l B x i l = 1 , i N ,
i N x i l = b , l B ,
k F y k l = 1 , l B ,
l B y k l = n k b , k F ,
x i l y k l , k F , i F k , l B ,
r l t l 0 , l B ,
r l + 1 t l + 1 r l , l B , l a ,
t l q k y k l , k F , l B ,
u i j + u j i = 1 , i , j N , i < j ,
j N , j i u j i + 1 β + M 1 ( 1 z l i ) , l B , l h + 1 , i N ,
j N , j i u j i + 1 β + ε + [ 1 β ε ] z l i , l B , l > h , i N ,
r l C i p i M 2 ( 1 z l i ) , l B , l > h , i N
C i p i C j M 2 u i j , i , j N , i j ,
C i p i r l M 3 ( 1 x i l ) , i N , l B ,
u i j { 0 , 1 } , i , j N , i j ,
y k l { 0 , 1 } , k F , l B ,
x i l { 0 , 1 } , i N , l B ,
z l i { 0 , 1 } , i N , l B .

4. Heuristic Design

4.1. Problem Decomposition

The dispatching rule is a simple heuristic whereby, whenever a machine is idle or a decision needs to be made, it calculates a priority for each queueing job and selects the job with the highest priority for processing. To take advantage of the dispatching rules, we decompose the problem into three sub-parts by the nature of the problem, namely, the batch formation, batch sequencing and job sequencing of the discrete processor. Thus, three dispatching rules are required for each decision point.
Specifically, the batch formation dispatching rule (BFDR) is applied to form jobs into batches, then a batch sequencing dispatching rule (BSDR) is utilized whenever the batch processor is idle, to decide the next batch to be processed on the batch processor. After that, whenever the discrete processor is idle, the job sequencing dispatching rule (JSDR) takes the responsibility of deciding the next job to be processed on the discrete processor.
For the sake of convenience, a schedule policy of our problem can be written as the combination of BFDR-BSDR-JSDR to represent the separate dispatching rules of three decision points clearly. For instance, FB-BSDR-SPT is a schedule policy that employs the full batch policy (FB) for batch formation, a dispatching rule (BSDR) for batch sequencing and the shortest processing time (SPT) rule for job sequencing.

4.2. Greedy Dealing Dispatching Rules Heuristic

In this section, we propose the greedy dealing dispatching rules (GDDR) heuristic for the problem of β δ | L B , I F | C i , in which, three dispatching rules are required for a decision point. The GDDR algorithm essentially provides the heuristic structure for solving the two-stage hybrid flow shop problems and illustrates the utilization of each dispatching rule. The detailed procedure of the GDDR heuristic is described as follows:
Greedy Dealing Dispatching Rules (GDDR)
Step 0. Input three dispatching rules (BFDR, BSDR and JSDR) for each decision point; set
job family index k = 1 .
Step 1. For job family k, sort jobs j F k in the non-decreasing order of processing time on
the discrete machine p j , i.e., p [ 1 ] p [ 2 ] p [ n k ] . Denote this job sequence as π k and
initialize a k empty batches. Set job index i = 1 and batch index b = 1 , where i = 1 , 2 , , n k
and b = 1 , 2 , , a k .
Step 2. Greedily try to assign the ith job of π k to each of a k , batches that still have space
remain, and calculate a priority for each possible batch assignment by applying BFDR;
Step 3. Assign the ith job of π k to the batch with the highest priority, break ties arbitrarily.
If i < n k , set i = i + 1 and go to Step 2; otherwise, go to Step 4.
Step 4. If k < m , set k = k + 1 and go to Step 1; otherwise, go to Step 5;
Step 5. Whenever the batch processor is idle, calculate priorities for all batches queueing in
front of the batch processor by applying BSDR;
Step 6. Select the batch with the highest priority to process on the batch processor and
remove this batch from the queue.
Step 7. Whenever the discrete processor is idle, calculate priorities for all queueing jobs in
the buffer by applying JSDR.
Step 8. Select the job with the highest priority to process on the discrete processor and
remove this job from the buffer.
Step 9. Repeat Steps 5–8 until all jobs are finished
The time complexity of GDDR is O ( n 2 ) and it generates a set of batches, a schedule of these batches on the batch processor and a schedule (with the completion time) of jobs processed on the discrete processor. Then we can calculate the objective (in this study, the total completion time) of the schedule.
Since the three dispatching rules in the GDDR can be any suitable existing dispatching rules, which dispatching rules should be used and how they cooperate with each other become difficult problems. In the next section, we deal with these problems by proposing a genetic programming-based hyper-heuristic to automatically generate dispatching rules for the GDDR algorithm.

5. Genetic Programming-Based Hyper-Heuristic

The three dispatching rules of GDDR can be generated by any problem-independent hyper-heuristic, such as GP, gene expression programming or neural network. Owing to the variable length encoding of expression tree representation, manually designed heuristics and domain knowledge can be easily expressed by GP [28], indicating that experts’ existing years of experience are available for GP. In this section, we propose a GP-based hyper-heuristic, where dispatching rules are utilized according to the GDDR algorithm and evaluated by a cooperative co-evolution strategy. Intuitively, the proposed algorithm is named as the GDDR-based cooperative co-evolutionary genetic programming (GDDR-CCGP). We first briefly introduce the basic GP used in the GDDR-CCGP, and then propose the GDDR-CCGP algorithm.

5.1. Genetic Programming

Genetic programming is an evolutionary computing method based on population evolution. A population of GP consists of a number of individuals, each individual is represented as an expression tree. As a hyper-heuristic, each individual corresponds to a dispatching rule. The leaf nodes of the expression tree are filled up with job attributes (terminals), e.g., job processing time, whereas other non-leaf nodes are filled up with functions including, but not limited to, arithmetic operators. As a simple example, the SPT rule can be represented as an expression tree with a negative operator in the root node and the processing time (PT) in the leaf node, resulting in an expression of 0 P T .
Individuals of GP are evolved by employing genetic operators, which include the sub-tree crossover, point mutation and ramped-half-and-half tree builder [16]. The sub-tree crossover generates new individuals by randomly selecting two nodes from two parents, then swapping the sub-trees of these two nodes while guaranteeing the maximum depth constraint is not violated; otherwise, it tries other nodes. Figure 2 presents an illustration of the sub-tree crossover operator, where the SPT rule and the minimum slack rule are selected as parents. As for point mutation, similar to sub-tree crossover, two random nodes are selected from parents, but replace the sub-tree of these two nodes with new generated trees by performing the ramped-half-and-half tree builder. Similarly, the maximum depth constraint cannot be violated; otherwise, it will try to generate another sub-tree. The parent individuals are randomly selected by applying the tournament selection.

5.2. GDDR-CCGP Algorithm

In order to deal with the multiple decision points of the studied problem, the proposed GDDR-CCGP adopts the cooperative co-evolution strategy, which is an efficient approach for solving problems with co-adapted sub-parts and strives to search for individuals that perform well together. It breaks a high-dimensional optimization space into several much simpler sub-spaces for sub-populations to search [29].
In the GDDR-CCGP algorithm, we divide the heuristic space into three sub-spaces each of which corresponds to a heuristic space of a decision point described previously. Then, three independent GPs are employed for each search on a sub-space. The cooperative co-evolution of the three GPs is realized during individual evaluation.
In the GDDR-CCGP algorithm, we employ three basic GPs to evolve the corresponding three dispatching rules required by the GDDR algorithm. Each GP has its own sub-population and thus, results in three sub-populations; P 1 = { p 1 , 1 , p 1 , 2 , } , P 2 = { p 2 , 1 , p 2 , 2 , } , and P 3 = { p 3 , 1 , p 3 , 2 , } represent the sub-populations of BFDR, BSDR, and JSDR, respectively. Thus, a schedule policy s consists of three rules from each sub-population.
The pseudo-code of the GDDR-CCGP algorithm is given in Algorithm 1. The GDDR-CCGP starts with the initialization of sub-populations by implementing the ramped-half-and-half tree builder. Then in each generation, every individual (dispatching rule) in the three sub-populations is evaluated in the form of schedule policy to obtain a fitness value (see next sub-section), which in turn governs the search behavior of the GDDR-CCGP. With the guidance of fitness values, the elites of each sub-population are selected to enter the next generation directly. Then, each sub-population is evolved independently by applying genetic operators from the sub-tree crossover and point mutation to generate the new sub-population of the next generation. The GDDR-CCGP moves to the next generation when there are sufficient number (popsize) of individuals for each sub-population. During the evaluation of individuals, each evaluated schedule policy s is recorded in a set S, and the best schedule policy is returned after the GDDR-CCGP is terminated. Figure 3 also graphically illustrates the procedure of the GDDR-CCGP algorithm.
Algorithm 1: GDDR-CCGP
Symmetry 14 00632 i001

5.3. Fitness Evaluation

Unlike conventional GP, the GDDR-CCGP evaluates individuals in groups, i.e., the fitness of an individual is decided by its performance in the context of individuals from other sub-populations. As a result, an individual is usually evaluated multiple times, each time with a different group of cooperative individuals. We denote each cooperation as a trial and the final fitness is calculated based on these multiple trials.
More specifically, for each trial an individual undertakes, the GDDR-CCGP combines the candidate individual of a certain sub-population with two cooperators selected from the other two sub-populations to form a schedule policy. Figure 3 presents an example of individual evaluation, where an individual of sub-population for BSDR is being evaluated.
Moreover, the selection of cooperators must address the problems of selection pressure, number of trials and trial credit assignment [30]. In this paper, we propose a two-trial evaluation scheme as described in Algorithm 1 (line 5–28). For the first trial, a candidate individual is cooperated with the best individuals of each other sub-population to form a schedule policy s. In the second trial, candidate individual is placed with two random individuals selected from each sub-population to form a schedule policy s . Then, the fitness of the candidate individual is defined as the best fitness values reached by s and s . In this way, we prevent the GDDR-CCGP algorithm from being too greedy while sustaining the ability of exploration.
Whenever a schedule policy is ready for evaluation, it is applied to the training instance set T to obtain a fitness. Algorithm 2 describes the procedure of fitness evaluation. For each instance T t T , we build a simulation based on the configuration of the instance. At the beginning of the simulation, all processors are idle and jobs are initialized according to instance T t . Then dispatching rules of the schedule policy are applied according to the procedure of the GDDR to make online decisions in the simulation. An objective value O t ( s ) is obtained when the simulation is finished. After all simulations of the training set T are finished, the fitness of the schedule policy is calculated by
f i t ( s ) = 1 | T | t = 1 | T | O t ( s ) O t ( r e f ) O t ( r e f ) × 100 ,
where O t ( r e f ) is the objective value reached by applying a benchmark algorithm or calculated by a lower bound. f i t ( s ) is essentially the average gap between evaluated schedule policy and benchmark algorithm. Thus, a lower f i t ( s ) indicates a better performance of the evaluated schedule policy.
Algorithm 2: eval(s, T)
Symmetry 14 00632 i002

6. Computational Experiments

In this section, computational experiments are conducted to evaluate the performance of the proposed GDDR-CCGP algorithm. The problem specified terminal sets and parameter settings are designed, and then the GDDR-CCGP algorithm is compared with the state-of-the-art algorithms of this two-stage hybrid flow shop scheduling problem.

6.1. Terminal Sets and Parameter Settings

The GPs’ terminals consist of basic attributes about the current job or batch and the “less-myopic” terminals which take into account information regarding environmental attributes associated with the current job or batch [31]. In order to solve the problem of β δ | L B , I F | C i efficiently, we customize the terminal sets of GPs based on the utilization of dispatching rules in the GDDR algorithm. Table 1 and Table 2 present the problem-specified terminals and the parameter settings of each GP. To provide more environment information for BFDR to assign a job to a correct batch, we involve M i n B W L and M a x B W L terminals to provide information about other batches. As for the terminal sets of GPs for BSDR and JSDR, the “less-myopic” terminals are utilized, which provides information on the other processor associated with the state of current processor. These “less-myopic” terminals consist of P T Q B , N J Q B , and B B T . By involving these three terminals, the generation of dispatching rules are allowed to adapt to the changing conditions of the upstream or downstream processor.
The function sets include four basic arithmetic operators, namely, + , , × , protected division ÷ which returns 1 when divided by 0, and a m a x operator which takes two arguments and returns the maximum value of them. Moreover, a ternary if-less-then-else (IfLT) is included and defined as follows:
I f L T ( x 1 , x 2 , x 3 ) = x 2 , x 1 < 0 x 3 , o t h e r w i s e ,
where x 1 , x 2 , x 3 are sub-expressions evolved by GP.
Function sets of the three GPs are of the same, except we extend the function set of GP for JSDR by adding the operator N e g ( 0 x 1 ), which returns the negative value of its argument. Since the scheduling problem of the job sequencing phase is a single machine total completion time minimization problem with a job release time, the SPT rule has been shown to be near optimal in most cases [32]. Thus, the addition of the N e g operation is based on the hope of providing opportunities for GP to evolve a dispatching rule that performs at least as good as the SPT rule ( 0 P T ) by combining operator N e g with the terminal P T .
Furthermore, as given in Table 2, the evolution parameter settings of three GPs are the same, where a high crossover rate is adopted with the hope of exploring more individuals. These evolution parameter settings are commonly used without paying much effort to parameter tuning, so that the contribution of the GDDR-CCGP algorithm is mainly owed to the well-designed heuristic structure, evaluation scheme, terminal set and function set.

6.2. Problem Instances Generation

Problem instances were generated randomly by adopting the idea of [3,7], and we extended their instances with additional large-scale instances. As a result, three instance sets were generated, namely, T s , T m , and T l , to test the performance of algorithms in small-scale, medium-scale and large-scale instances. A configuration of the problem is represented by the combination n m b h , which describes the total number of jobs and job families, batch capacity and buffer size of a problem configuration. For each problem configuration n m b h , we randomly generated 50 instances by applying the following parameters:
  • job processing time of job i: p i U 1 , 10 ;
  • batch processing time of job family k: q k U b n i = 1 n p i 10 , b n i = 1 n p i + 10 ;
  • total number of jobs in job family k: n k = n m b , k = 1 , 2 , , m 1 , and n m = n k 1 m 1 n k .
The parameters of each instance set are listed as below:
  • T s : n = { 40 , 60 , 80 } , m = { 2 , 4 } , b = { 5 , 10 } , h = { 2 , 3 } ;
  • T m : n = { 100 , 200 , 300 , 400 } , m = { 2 , 4 , 10 } , b = { 10 , 20 } , h = { 2 , 3 } ;
  • T l : n = { 600 , 900 , 1200 } , m = { 10 , 20 } , b = { 10 , 20 } , h = 2 .
T l is mainly distinguished by its larger number of jobs and job families. Furthermore, the buffer size is restricted to two as a smaller buffer size generally leads to a more complex problem. T l was designed with the aim of testing the effectiveness and robustness of the evolved schedule policy in unseen and more complex problem configurations. Moreover, an additional filter of n m b < 1 is applied to get rid of simple configurations and results in 82 configurations (24, 46 and 12 configurations for T s , T m , and T l , respectively) consisting of 4100 instances.

6.3. Comparison Results

In order to evaluate the performance of the proposed GDDR-CCGP problem, three algorithms proposed by [3] were selected as benchmarks, namely, a greedy dealing shortest processing time (GDSPT) heuristic, a recycled differential evolution (RDE) algorithm, and the RDE with only one iteration, which is denoted by IDE. GDDR-CCGP was coded in Java on the basis of the ECJ library (https://cs.gmu.edu/~eclab/projects/ecj/ (accessed on 1 October 2021)) and the benchmark algorithms were coded in C++. All algorithms were run on an Inter Xeon CPU 2.4 GHz computer with 16.0 GB of RAM.
The GDSPT heuristic forms batches by using a modified full batch policy (FB), then sorts batches in non-decreasing order of the batch processing time B P T and total processing time B P T + B W L , which results in two batch sequencing solutions. After that, jobs are processed on the discrete processor according to the SPT rule. Finally, the solution is returned with the better objective value of the two solutions. Thus, the GDSPT heuristic can be written as FB-GDSPT-SPT.
The RDE algorithm extends the differential evolution with a recycle technique, which allows the solution of a differential evolution iteration to be used in the population of the next iteration for improving the solution quality. The RDE (IDE) was proposed to make batch sequencing decisions and is cooperated with the FB and the SPT for batch formation and job sequencing, respectively. Thus, the RDE (IDE) algorithm is essentially a schedule policy of FB-RDE (IDE)-SPT. In our experiments, the RDE algorithm was terminated after sustaining the same best solution after 40 iterations.
Since the GDDR-CCGP is stochastic, we preliminarily ran the GDDR-CCGP 50 times independently with different seeds, then the best schedule policy, denoted by GDDR, was selected for comparison in the following experiments.
For the sake of simplicity, some new notations are introduced as follows:
Obj: 
the objective value reached by applying an algorithm on an instance;
Hh: 
any algorithm h;
LB: 
the composite lower bound developed by [3];
Dif: 
the difference in percentage between an algorithm and the lower bound;
:  
H 1 H 2 indicates H 2 outperforms H 1 .
In this section, the total completion time difference relative to the objective value reached by the L B is reported, which is calculated by
D i f ( H ) = O b j ( H ) O b j ( L B ) O b j ( L B ) × 100 .
It is obvious that, D i f ( H ) is greater than zero and D i f ( H 2 ) < D i f ( H 1 ) indicates that H 1 H 2 .
Table 3 and Table 4 report the differences between the corresponding algorithm and LB when tested on instance sets T s and T m . The T i m e ( s ) , A v g ( % ) , and M a x ( % ) represent the average run time, average differences, and maximum differences among 50 instances of each problem configuration. All average performance values were tested for statistically significant differences using the paired t-test. The values marked with letters indicate the GDDR significantly outperforms different benchmark algorithms at 5% significant level with regard to corresponding problem configuration, where “a”, “b”, and “c” represent the GDSPT, IDE, and RDE algorithms, respectively. The run times of GDSPT are not reported because the time costs for all instances are less than 0.01 s.
As observed from Table 3, in terms of A v g values, GDDR dominates GDSPT, IDE, and RDE on 23 (95.83%), 22 (91.67%), and 22 (83.33%) configurations out of all 24 configurations. As for the M a x values, GDDR dominates all the other algorithms with 21 (87.50%) configurations. Statistically, GDDR significantly outperforms GDSPT, IDE, and RDE on 21 (87.50%), 18 (75.00%), and 18 (75.00%) configurations, respectively. In terms of average run time, GDDR obtains results within 0.01 s for all configurations.
Table 4 shows the comparison results on the medium-scale instance set T m . Similarly, GDDR dominates GDSPT on all configurations in terms of both A v g values and M a x values. When compared with IDE and RDE with regard to the A v g values, GDDR wins on 44 (95.65%) and 37 (80.43%) configurations out of all 46 configurations. As for the M a x values, GDDR wins on 44 (95.65%) and 39 (84.78%) configurations. Statistically, GDDR significantly outperforms GDSPT, IDE, and RDE on 46 (100.00%), 44 (95.65%) and 34 (73.91%) configurations, respectively. Furthermore, the maximum values of A v g and M a x for GDDR are 2.87% and 6.60%, respectively. Indicating the near optimal performance of the evolved schedule policy. In terms of overall performance, it can be calculated from Table 4 that, GDDR provides 40.55%, 33.24% and 24.55% average improvement to GDSPT, IDE, and RDE, respectively. It is noticeable that, GDDR still costs almost no time, whereas the average time cost of the RDE increases sharply as the complexity of the instance increases. Specifically, the maximum average time cost of GDDR is about 0.03 s, in sharp contrast to 217.06 s for RDE.
Combing the results of Table 3 and Table 4, it can be concluded that GDDR can provide promising solutions that significantly outperform GDSPT, IDE, and RDE in most tested configurations. Figure 4 graphically shows the A v g values of all algorithms based on the numerical results in Table 3 and Table 4. In Figure 4, the average difference of the GDDR is always the smallest and gaps between the GDDR and other algorithms increase with the increasing of number of jobs. This result indicates that GDDR outperforms benchmark algorithms especially in complex problem configurations.
Figure 5 presents the box plots of all A v g values and M a x values reached by the GDDR and three benchmark algorithms in Table 3 and Table 4. It can be observed that the GDDR results in a smaller interquartile range than the benchmark rules in terms of both A v g value and M a x value, which indicates that the performance of the GDDR is stabler. Furthermore, the slot of GDDR has a lower maximum, minimum and three quartiles values. Figure 5 shows the same result as Figure 4 and indicates the performance of the GDDR is superior to the three benchmark algorithms.
To verify the observed result is statistically significant, we conducted a paired t-test with a significance level of 5% between GDDR and each of the compared algorithms, based on the results in Table 3 and Table 4. The hypothesis and the calculated p-values are listed as follows:
  • T1 ( H 0 : A v g ( G D D R G D S P T ) = 0 and H 1 : A v g ( G D D R G D S P T ) < 0 ), p = 2.72 × 10 19 ;
  • T2 ( H 0 : A v g ( G D D R I D E ) = 0 and H 1 : A v g ( G D D R I D E ) < 0 ), p = 6.61 × 10 15 ;
  • T3 ( H 0 : A v g ( G D D R R D E ) = 0 and H 1 : A v g ( G D D R R D E ) < 0 ), p = 2.08 × 10 11 .
Obviously, the null hypothesis H 0 is rejected for all hypothesis, which indicates that GDDR significantly outperforms GDSPT, IDE, and RDE. Consequently, based on the dominant ratios and p-values, we can further conclude that GDSPT ≺ IDE ≺ RDE ≺ GDDR.
In order to evaluate the robustness ability of GDDR, we further test GDDR on large-scale instance set T l , which contains instances that the GDDR never saw during the training phase. Table 5 presents the computational results on large-scale instance set T l . The run time of RDE is limited to around 600 s, whereas other parameter settings remain unchanged.
As we can observe from Table 5, GDDR significantly outperforms all benchmark algorithms in all configurations with regard to A v g value and M a x value. As for time cost, the run time of RDE starts exceeding 600 s when n increases to 1200 and GDDR keeps finishing calculations within a second. These results demonstrate the reusable ability of GDDR, it sustains effective and efficient performances when being applied to unseen complex problem instances.

7. Discussion

To investigate more insights of the studied problem and discuss the effectiveness of the proposed GDDR-CCGP algorithm, we conducted additional experiments to compare the GDDR-CCGP with GP’s counterpart. The dispatching rules of some decision points are unchanged, and they only evolve the dispatching rules of the remaining decision points. Based on the GDSPT (FB-GDSPT-SPT) algorithm, we substitute the dispatching rule of each decision point with GP and do not change the other dispatching rules. As a result, the counterpart GPs are denoted as BFGP (GP-GDSPT-SPT), BSGP (FB-GP-SPT) and BatchCCGP (GP-GP-SPT, a cooperative co-evolutionary genetic programming with two co-evolving sub-populations). For fair comparisons, the terminal sets and parameter settings are identical to corresponding sub-parts of the GDDR-CCGP as listed in Table 1 and Table 2. The population sizes of BFGP, BSGP and BatchCCGP are set to 3000, 3000 and 750, respectively. Therefore, all GPs get the same number of fitness evaluations per generation as GDDR-CCGP.
In this experiment, we ran all GPs 50 times and common random seeds were utilized across the GPs to provide the same set of evaluation environments, and result in 50 schedule policies for each GP. Then, each schedule policy was tested on the instance set T m to obtain the total objective value of all test instances as the performance criterion of the schedule policy. After that, the average performance of the 50 schedule policies of a GP were compared with others. Table 6 reports the absolute mean performance differences of the GPs based on 50 runs of each GP, where a positive value indicates the GP in the column header is better than the GP in the first column of the current row. Furthermore, in order to provide indicators of statistical significance, we again employed the paired t-test with a significance level of 5% and “+” indicates significant, “o” otherwise.
As observed from Table 6, BFGP significantly outperforms BSGP. In addition, in terms of absolute mean performance difference values, BatchCCGP improves BSGP by the value of 1,139,683.64, which is much larger than the improvement in BFGP. These results imply that the GP for the batch formation phase can better improve the optimization of the problem than the GP for the batch sequencing phase. Meanwhile, the GPs with cooperative co-evolution (BatchCCGP and GDDR-CCGP) are significantly better than the GPs which only evolve dispatching rules on a single decision point (BFGP and BSGP). This result demonstrates the necessity of a cooperative co-evolution strategy for the studied problem. As for the comparison between BatchCCGP and GDDR-CCGP, although the absolute mean performance difference shows the superiority of the former, the statistical result reports a non-significant indicator. In summary, we can at least conclude that BSGP ≺ BFGP ≺ BatchCCGP ≈ GDDR-CCGP.
In order to compare the optimization ability of BatchCCGP and GDDR-CCGP, a comparison was conducted based on results of the 50 evolved schedule policies of each GP. As shown in Table 7, each GP was compared with the three benchmark algorithms and the overall improvement ratio (a negative ratio indicates the improvement provided by GPs) and dominant ratio (number of dominant configurations divided by total number of configurations) was obstained against each benchmark algorithm. The average and best values are reported.
As observed from Table 7, BatchCCGP outperforms the GDDR-CCGP in all average values, this result is consistent with the statistical results of Table 6. However, in terms of best values, GDDR-CCGP shows a better performance than BatchCCGP. Overall, GDDR-CCGP provided additional 2–4% improvements in comparison to BatchCCGP and dominated RDE on a larger number of configurations. As we described earlier, the SPT rule provides near optimal solutions for the job sequencing phase, the results in Table 6 and Table 7 show that the addition of GP for job sequencing phase does not promise a better result, but does provide opportunity for a GP to evolve better dispatching rules. Thus, we conclude that the GDDR-CCGP is capable of generating better dispatching rules than BatchCCGP without guaranteeing superior performance on every run.
Moreover, when comparing the results between BFGP and BSGP, the former significantly outperforms the latter in all average values. Although the best values of BSGP are better, in our experiments, only two runs of BSGP yield better results than BFGP among 50 runs, whereas the other 48 runs are significantly worse than BFGP. This indicates that, the GP for the batch formation phase can contribute much more than that for the batch sequencing phase.
Finally, as for the comparison between BSGP and RDE, since they are both optimized on the batch sequencing phase, this is a comparison between the GP-generated heuristic and well-designed meta-heuristic. As well-known, it is difficult for a heuristic to beat a meta-heuristic. However, it is noticeable that, the best schedule policy evolved by BSGP outperforms RDE with a 13.04% improvement ratio and a 65.22% dominant ratio. This remarkable result indicates that some dispatching rules can compete with a meta-heuristic, and again demonstrates the effectiveness of the proposed GDDR-CCGP algorithm.

8. Conclusions

In this study, we address the two-stage hybrid flow shop scheduling problem with a batch processor followed by a discrete processor. An incompatible job family and size-limited buffer are also considered. In order to provide an online real-time decision-making solution, we propose the GDDR heuristic with three dispatching rules for the three corresponding decision points of batch formation, batch sequencing and job sequencing. In addition, a genetic programming with cooperative co-evolution (GDDR-CCGP) is proposed as the hyper-heuristic for evolving schedule policies.
The experimental results show that the evolved best schedule policy GDDR outperforms the benchmark heuristic and meta-heuristics in terms of solution quality and run time, and that the GDDR can provide high quality solutions especially for large-scale instances within few seconds. These results demonstrate that the proposed GDDR-CCGP is capable of generating high-quality schedule policies for making real-time scheduling decisions for the studied problem.
We further analyze the optimization contribution of each decision point. The numerical results show that, optimization of the batch formation phase contributes the most, followed by the batch sequencing phase and then the job sequencing phase. Since the SPT rule is near optimal for the job sequencing phase, evolving dispatching rules for the job sequencing phase provides opportunity for better schedule polices. Thus, the hyper-heuristic for the job sequencing phase is optional but strongly recommended.
The proposed GDDR-CCGP can be easily extended to other flow shop set-ups where cooperation between the batch processor and discrete processor exists. More importantly, the evolved schedule policy offers a powerful schedule tool in a real dynamic manufacturing environment, which provides competitive solution quality in a short time and allows for quick reactions to the dynamic changes. Even when the production environment is changed, a new run of the GDDR-CCGP can be implemented offline by simply updating training data and obtaining a more suitable scheduling policy without interrupting the production.
Future works will focus on extending the proposed GDDR-CCGP algorithm to multi-stage hybrid flow shop scheduling problems and dealing with multi-objective functions. Additionally, research on the scheduling problem of a more general complex dynamic job shop where batch processors and discrete processors exist, is also a meaningful direction.

Author Contributions

Conceptualization, L.S.; methodology, L.L. and L.S.; computation experiments, L.L.; writing, L.L. All authors have read and agreed to the published version of the manuscript.

Funding

This research was supported in part by National Science Foundation of China [grant number 71690232].

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Acknowledgments

The authors would like to thank Cheng Zhang for his support and contributions during the development of this work.

Conflicts of Interest

The authors declare no conflict of interest.

Notations

ntotal number of jobs;
mtotal number of incompatible job families;
bbatch capacity;
hthe maximum number of batches the buffer can hold;
Fincompatible job families set, where F = { 1 , 2 , , m } ;
n k total number of jobs in family k, where k = 1 , 2 , , m ;
F k set of jobs belonging to family k, F k = { 1 , 2 , , n k } , k F ;
a k number of batches in family k, i.e., a k = n k b , where k = 1 , 2 , , m ;
q k processing time on the batch processor for family k, where k = 1 , 2 , , m ;
p i processing time on the discrete processor for job i, where i = 1 , 2 , , n ;
Njob set, where N = { 1 , 2 , , n } ;
Bthe batch set, where B = { 1 , 2 , , a } and a = n / b ;
ε a sufficient small positive number;
M i a sufficient large positive number, where i = 1 , 2 , 3 .

Variables

x i l x i l = 1 if job i is assigned to batch l, and 0 otherwise;
y k l y k l = 1 if batch l consists of the jobs in job family k, and otherwise, y k l = 0 ;
z l i z l i = 1 if the position of job i in the process sequence of the discrete processor is less than or
equal to ( l h ) b , and otherwise, z l i = 0 , for all l > h , let β = ( l h ) b ;
u i j u i j = 1 if job i is processed before job j on the discrete processor, and otherwise, u i j = 0 ;
t l the processing time of batch l;
r l the release time of batch l on the batch processor;
C i the completion time of job i.

References

  1. Mathirajan, M.; Sivakumar, A.I. A literature review, classification and simple meta-analysis on scheduling of batch processors in semiconductor. Int. J. Adv. Manuf. Technol. 2006, 29, 990–1001. [Google Scholar] [CrossRef]
  2. Graham, R.L.; Lawler, E.L.; Lenstra, J.K.; Kan, A.R. Optimization and approximation in deterministic sequencing and scheduling: A survey. In Annals of Discrete Mathematics; Elsevier: Amsterdam, The Netherlands, 1979; Volume 5, pp. 287–326. [Google Scholar]
  3. Zhang, C.; Shi, Z.; Huang, Z.; Wu, Y.; Shi, L. Flow shop scheduling with a batch processor and limited buffer. Int. J. Prod. Res. 2017, 55, 3217–3233. [Google Scholar] [CrossRef]
  4. Ahmadi, J.H.; Ahmadi, R.H.; Dasu, S.; Tang, C.S. Batching and scheduling jobs on batch and discrete processors. Oper. Res. 1992, 40, 750–763. [Google Scholar] [CrossRef]
  5. Branke, J.; Nguyen, S.; Pickardt, C.W.; Zhang, M. Automated design of production scheduling heuristics: A review. IEEE Trans. Evol. Comput. 2015, 20, 110–124. [Google Scholar] [CrossRef] [Green Version]
  6. Su, L.H.; Yang, D.L.; Chou, H.K. A two-stage flowshop scheduling with limited buffer storage. Asia-Pac. J. Oper. Res. 2009, 26, 503–522. [Google Scholar] [CrossRef]
  7. Fu, Q.; Sivakumar, A.I.; Li, K. Optimisation of flow-shop scheduling with batch processor and limited buffer. Int. J. Prod. Res. 2012, 50, 2267–2285. [Google Scholar] [CrossRef]
  8. Shi, Z.; Huang, Z.; Shi, L. Two-stage flow shop with a batch processor and limited buffer. In Proceedings of the 2016 IEEE International Conference on Automation Science and Engineering (CASE), Fort Worth, TX, USA, 21–25 August 2016; pp. 395–400. [Google Scholar]
  9. Mauluddin, Y. Three-stage flow-shop scheduling model with batch processing machine and discrete processing machine. In MATEC Web of Conferences; EDP Sciences: Les Ulis, France, 2018; Volume 197, p. 14002. [Google Scholar]
  10. Ross, H.L.F.P.; Corne, D. A promising hybrid GA/heuristic approach for open-shop scheduling problems. In Proceedings of the 11th European Conference on Artificial Intelligence, Amsterdam, The Netherlands, 8–12 August 1994; pp. 590–594. [Google Scholar]
  11. Rodríguez, J.V.; Petrovic, S.; Salhi, A. A combined meta-heuristic with hyper-heuristic approach to the scheduling of the hybrid flow shop with sequence dependent setup times and uniform machines. In Proceedings of the 3rd Multidisciplinary International Conference on Scheduling: Theory and Applications, MISTA, Paris, France, 28–31 August 2007; pp. 506–513. [Google Scholar]
  12. Burke, E.K.; McCollum, B.; Meisels, A.; Petrovic, S.; Qu, R. A graph-based hyper-heuristic for educational timetabling problems. Eur. J. Oper. Res. 2007, 176, 177–192. [Google Scholar] [CrossRef] [Green Version]
  13. Sim, K.; Hart, E.; Paechter, B. A hyper-heuristic classifier for one dimensional bin packing problems: Improving classification accuracy by attribute evolution. In Proceedings of the International Conference on Parallel Problem Solving from Nature, Taormina, Italy, 1–5 September 2012; Springer: Berlin/Heidelberg, Germany, 2012; pp. 348–357. [Google Scholar]
  14. Runka, A. Evolving an edge selection formula for ant colony optimization. In Proceedings of the 11th Annual Conference on Genetic and Evolutionary Computation, Montreal, QC, USA, 8–12 July 2009; pp. 1075–1082. [Google Scholar]
  15. Bader-El-Den, M.; Poli, R.; Fatima, S. Evolving timetabling heuristics using a grammar-based genetic programming hyper-heuristic framework. Memetic Comput. 2009, 1, 205–219. [Google Scholar] [CrossRef]
  16. Koza, J.R. Genetic Programming II: Automatic Discovery of Reusable Subprograms; MIT Press: Cambridge, MA, USA, 1994; Volume 13, p. 32. [Google Scholar]
  17. Miyashita, K. Job-shop scheduling with genetic programming. In Proceedings of the 2nd Annual Conference on Genetic and Evolutionary Computation, Las Vegas, NV, USA, 10–12 July 2000; pp. 505–512. [Google Scholar]
  18. Dimopoulos, C.; Zalzala, A.M. Investigating the use of genetic programming for a classic one-machine scheduling problem. Adv. Eng. Softw. 2001, 32, 489–498. [Google Scholar] [CrossRef]
  19. Geiger, C.D.; Uzsoy, R.; Aytuğ, H. Rapid modeling and discovery of priority dispatching rules: An autonomous learning approach. J. Sched. 2006, 9, 7–34. [Google Scholar] [CrossRef]
  20. Geiger, C.D.; Uzsoy, R. Learning effective dispatching rules for batch processor scheduling. Int. J. Prod. Res. 2008, 46, 1431–1454. [Google Scholar] [CrossRef]
  21. Hildebrandt, T.; Goswami, D.; Freitag, M. Large-scale simulation-based optimization of semiconductor dispatching rules. In Proceedings of the Winter Simulation Conference 2014, Savannah, GA, USA, 7–10 December 2014; pp. 2580–2590. [Google Scholar]
  22. Shi, Z.; Gao, S.; Du, J.; Ma, H.; Shi, L. Automatic design of dispatching rules for real-time optimization of complex production systems. In Proceedings of the 2019 IEEE/SICE International Symposium on System Integration (SII), Paris, France, 14–16 January 2019; pp. 55–60. [Google Scholar]
  23. Nguyen, S.; Zhang, M.; Johnston, M.; Tan, K.C. Genetic programming for job shop scheduling. In Evolutionary and Swarm Intelligence Algorithms; Springer: Berlin/Heidelberg, Germany, 2019; pp. 143–167. [Google Scholar]
  24. Park, J.; Nguyen, S.; Zhang, M.; Johnston, M. Genetic programming for order acceptance and scheduling. In Proceedings of the 2013 IEEE Congress on Evolutionary Computation, Cancún, Mexico, 20–23 June 2013; pp. 1005–1012. [Google Scholar]
  25. Nguyen, S.; Zhang, M.; Johnston, M.; Tan, K.C. Automatic design of scheduling policies for dynamic multi-objective job shop scheduling via cooperative coevolution genetic programming. IEEE Trans. Evol. Comput. 2013, 18, 193–208. [Google Scholar] [CrossRef]
  26. Yska, D.; Mei, Y.; Zhang, M. Genetic programming hyper-heuristic with cooperative coevolution for dynamic flexible job shop scheduling. In Proceedings of the European Conference on Genetic Programming, Parma, Italy, 4–6 April 2018; Springer: Berlin/Heidelberg, Germany, 2018; pp. 306–321. [Google Scholar]
  27. Uzsoy, R. Scheduling batch processing machines with incompatible job families. Int. J. Prod. Res. 1995, 33, 2685–2708. [Google Scholar] [CrossRef]
  28. Burke, E.K.; Hyde, M.R.; Kendall, G.; Ochoa, G.; Ozcan, E.; Woodward, J.R. Exploring hyper-heuristic methodologies with genetic programming. In Computational Intelligence; Springer: Berlin/Heidelberg, Germany, 2009; pp. 177–201. [Google Scholar]
  29. Luke, S. Essentials of Metaheuristics. Lulu. 2011. Available online: http://cs.gmu.edu/sean/book/metaheuristics/ (accessed on 1 October 2021).
  30. Wieg, R.P.; Liles, W.C.; De Jong, K.A. An empirical analysis of collaboration methods in cooperative coevolutionary algorithms. In Proceedings of the Genetic and Evolutionary Computation Conference (GECCO), San Francisco, CA, USA, 7–11 July 2001; Volume 2611, pp. 1235–1245. [Google Scholar]
  31. Hunt, R.; Johnston, M.; Zhang, M. Evolving “less-myopic” scheduling rules for dynamic job shop scheduling with genetic programming. In Proceedings of the 2014 Annual Conference on Genetic and Evolutionary Computation, Vancouver, BC, Canada, 12–16 July 2014; pp. 927–934. [Google Scholar]
  32. Chang, Y.L.; Sueyoshi, T.; Sullivan, R.S. Ranking dispatching rules by data envelopment analysis in a job shop environment. IIE Trans. 1996, 28, 631–642. [Google Scholar] [CrossRef]
Figure 1. An illustration of the two-stage hybrid flow shop with incompatible job families and size limited buffer constraints.
Figure 1. An illustration of the two-stage hybrid flow shop with incompatible job families and size limited buffer constraints.
Symmetry 14 00632 g001
Figure 2. An illustration of the sub-tree crossover operator.
Figure 2. An illustration of the sub-tree crossover operator.
Symmetry 14 00632 g002
Figure 3. Procedure of the GDDR-CCGP algorithm. An individual from the sub-population for BFDR is being evaluated.
Figure 3. Procedure of the GDDR-CCGP algorithm. An individual from the sub-population for BFDR is being evaluated.
Symmetry 14 00632 g003
Figure 4. Average difference analysis for different numbers of job family of numerical results from T s and T m . (a) m = 2 , b = 10 , h = 2 . (b) m = 4 , b = 10 , h = 2 .
Figure 4. Average difference analysis for different numbers of job family of numerical results from T s and T m . (a) m = 2 , b = 10 , h = 2 . (b) m = 4 , b = 10 , h = 2 .
Symmetry 14 00632 g004
Figure 5. Box-plots of average and maximum differences for each method based on numerical results from T s and T m . (a) Box-plot of average differences. (b) Box-plot of maximum differences.
Figure 5. Box-plots of average and maximum differences for each method based on numerical results from T s and T m . (a) Box-plot of average differences. (b) Box-plot of maximum differences.
Symmetry 14 00632 g005
Table 1. Terminals of GDDR-CCGP for the problem of β δ | L B , I F | C i .
Table 1. Terminals of GDDR-CCGP for the problem of β δ | L B , I F | C i .
NotationDescription
PTThe processing time of a job on the discrete processor
BPTThe processing time of a batch on the batch processor
BWLWork load of a batch, calculated by sum of PTs of all jobs in a batch
MinBWLWhen a job is assigned to a batch, the minimum BWL of the remaining batches
MaxBWLWhen a job is assigned to a batch, the maximum BWL of the remaining batches
BSRThe number of space units remaining for a batch
BBTThe time of batch blocking in the batch processor
FPTRSum of PTs remaining for a job family
PTQBSum of PTs queueing in the buffer
NJQBNumber of jobs queueing in the buffer
ERCA random constant from 1 to 1
Table 2. Parameter settings of GDDR-CCGP for the problem of β δ | L B , I F | C i .
Table 2. Parameter settings of GDDR-CCGP for the problem of β δ | L B , I F | C i .
ParameterValue
Terminal set of GP for BFDRPT, BPT, BWL, MinBWL, MaxBWL, FPTR, BSR, 0, 1
Terminal set of GP for BSDRBPT, BWL, PTQB, NJQB,0, 1
Terminal set of GP for JSDRPT, PTQB, NJQB, BBT, ERC
Function set+, −, ×, ÷, Max, IfLT, (Neg)
InitializationRamped-half-and-half tree builder
Population size500
Generation50
Crossover rate95%
Mutation rate5%
Elitism20
Max. tree depth17
Individual selectionTournament selection (size 7)
Cooperators1 elite of last generation, 1 random
Table 3. Numerical results of the small-scale instance set T s , relative to the lower bound. The values marked with letters indicate the GDDR significantly outperforms different benchmark algorithms at 5% significant level, where “a”, “b”, and “c” represent the GDSPT, IDE, and RDE algorithms, respectively. Run time of GDSPT is omitted because it finishes all instances within a second.
Table 3. Numerical results of the small-scale instance set T s , relative to the lower bound. The values marked with letters indicate the GDDR significantly outperforms different benchmark algorithms at 5% significant level, where “a”, “b”, and “c” represent the GDSPT, IDE, and RDE algorithms, respectively. Run time of GDSPT is omitted because it finishes all instances within a second.
GDSPTIDERDEGDDR
n-m-b-hAvg (%)Max (%)Time (s)Avg (%)Max (%)Time (s)Avg (%)Max (%)Time (s)Avg (%)Max (%)
40-2-5-26.6222.940.076.3822.941.136.2622.760.014.50 a,b,c15.90
40-2-5-36.7230.600.076.5330.171.066.3930.170.005.16 a,b,c25.31
40-2-10-22.086.070.042.086.070.042.086.070.001.59 a,b,c5.57
40-2-10-31.967.450.041.967.450.031.967.450.001.60 a,b,c6.65
40-4-5-25.4513.500.065.0313.500.954.7613.500.004.93 a16.31
40-4-5-34.1317.590.063.7915.750.963.5915.440.004.06 b,c13.88
40-4-10-21.345.000.011.345.000.011.345.000.001.245.09
40-4-10-31.366.420.011.366.420.011.366.420.001.418.49
60-2-5-27.9331.270.117.6029.182.507.4928.620.005.12 a,b,c21.22
60-2-5-35.1729.180.124.9728.292.454.8827.660.003.94 a,b,c22.32
60-2-10-22.118.940.092.058.191.112.027.850.001.67 a,b,c4.90
60-2-10-32.327.680.102.147.321.302.117.320.001.91 a5.29
60-4-5-25.7018.920.115.3218.212.935.1016.810.004.12 a,b,c11.57
60-4-5-36.5123.060.106.3022.772.436.1022.640.005.22 a,b,c18.83
60-4-10-22.409.210.072.117.321.091.996.640.001.96 a5.22
60-4-10-32.116.530.081.796.271.101.676.190.001.69 a4.70
80-2-5-27.1928.800.196.9328.515.266.7727.300.004.35 a,b,c19.18
80-2-5-36.3321.190.226.2321.194.816.1320.880.004.46 a,b,c18.04
80-2-10-22.529.490.112.428.832.192.398.580.001.69 a,b,c4.52
80-2-10-32.079.060.121.948.892.181.918.890.001.50 a,b,c4.26
80-4-5-26.9722.850.186.4621.585.456.1920.700.004.43 a,b,c12.62
80-4-5-36.6017.390.186.4017.345.156.1117.200.004.31 a,b,c11.02
80-4-10-22.126.990.131.846.582.281.706.430.001.66 a5.84
80-4-10-32.488.530.132.097.452.211.927.450.001.72 a,b,c5.34
Table 4. Numerical results of the medium-scale instance set T m , relative to the lower bound. The values marked with letters indicate the GDDR significantly outperforms different benchmark algorithms at 5% significant level, where “a”, “b”, and “c” represent the GDSPT, IDE, and RDE algorithms, respectively. Run time of GDSPT is omitted because it finishes all instances within a second.
Table 4. Numerical results of the medium-scale instance set T m , relative to the lower bound. The values marked with letters indicate the GDDR significantly outperforms different benchmark algorithms at 5% significant level, where “a”, “b”, and “c” represent the GDSPT, IDE, and RDE algorithms, respectively. Run time of GDSPT is omitted because it finishes all instances within a second.
GDSPTIDERDEGDDR
n-m-b-hAvg (%)Max (%)Time (s)Avg (%)Max (%)Time (s)Avg (%)Max (%)Time (s)Avg (%)Max (%)
100-2-10-22.289.650.392.219.454.142.169.270.011.63 a,b,c4.58
100-2-10-32.428.370.162.328.253.912.288.190.011.64 a,b,c5.04
100-2-20-21.074.130.120.973.371.930.953.250.000.75 a,b,c2.81
100-2-20-31.023.190.120.933.021.950.913.020.000.71 a,b,c2.31
100-4-10-22.288.370.162.037.884.371.897.700.001.68 a,b,c5.67
100-4-10-32.918.320.162.637.174.292.466.910.001.97 a,b,c4.58
100-4-20-20.932.810.090.732.371.810.692.270.000.74 a2.65
100-4-20-30.823.750.080.652.091.790.581.830.000.65 a2.87
100-10-10-23.298.240.112.535.594.321.994.700.002.32 a,b5.50
100-10-10-32.898.640.112.186.114.371.725.300.002.04 a,b5.34
200-2-10-23.2712.240.713.2212.1827.223.1611.770.011.67 a,b,c6.87
200-2-10-33.058.620.693.038.5926.082.988.530.011.67 a,b,c4.80
200-2-20-21.403.790.401.283.6912.201.253.640.010.84 a,b,c2.14
200-2-20-31.543.930.411.403.9312.941.373.930.010.94 a,b,c2.30
200-4-10-22.7112.440.692.6112.2527.422.4711.910.001.65 a,b,c6.70
200-4-10-33.449.540.663.339.5228.243.189.210.011.75 a,b,c4.36
200-4-20-21.414.060.411.203.3812.191.072.980.011.00 a,b2.63
200-4-20-31.464.060.411.193.0812.261.082.940.001.02 a,b2.44
200-10-10-22.906.510.672.655.8428.642.135.740.001.82 a,b,c4.34
200-10-10-32.936.980.662.696.9028.882.146.550.011.85 a,b,c5.74
200-10-20-21.654.550.281.122.4213.500.822.030.001.02 a,b2.06
200-10-20-31.513.490.291.153.1112.690.852.190.001.04 a,b2.43
300-2-10-23.1913.991.823.1313.9983.253.0713.780.031.76 a,b,c7.65
300-2-10-33.3710.311.813.3610.3183.093.3110.210.021.92 a,b,c7.25
300-2-20-21.294.920.991.244.8437.361.224.650.020.71 a,b,c2.04
300-2-20-31.244.141.031.194.1436.021.164.120.010.71 a,b,c2.06
300-4-10-24.4212.211.834.2511.96103.034.0211.300.011.97 a,b,c5.43
300-4-10-33.297.541.813.267.5499.553.097.470.021.65 a,b,c3.85
300-4-20-21.474.771.031.334.2241.671.244.140.010.82 a,b,c2.03
300-4-20-31.494.370.991.303.8040.711.193.620.010.81 a,b,c1.97
300-10-10-23.108.151.802.976.83105.322.436.400.011.61 a,b,c4.00
300-10-10-33.209.791.833.128.7397.752.717.580.011.73 a,b,c4.77
300-10-20-21.625.350.881.213.3139.390.932.960.010.99 a,b2.60
300-10-20-31.644.700.891.273.6440.200.973.260.010.95 a,b2.59
400-2-10-24.1315.823.833.9214.82217.063.7714.450.032.26 a,b,c9.80
400-2-10-34.2811.404.074.2611.40161.524.2411.400.032.54 a,b,c8.06
400-2-20-21.584.512.291.564.5183.831.534.490.020.76 a,b,c1.77
400-2-20-31.494.762.031.454.7684.411.414.680.020.70 a,b,c1.92
400-4-10-23.4911.623.853.3711.50198.543.1710.160.021.46 a,b,c4.95
400-4-10-33.209.443.823.199.44189.063.119.280.021.58 a,b,c5.25
400-4-20-21.463.612.021.383.5492.611.283.520.010.81 a,b,c1.71
400-4-20-31.554.191.991.423.5799.641.313.530.020.83 a,b,c1.82
400-10-10-23.1610.533.803.039.51214.822.748.270.011.49 a,b,c4.02
400-10-10-32.977.743.782.927.60216.612.577.600.011.42 a,b,c4.46
400-10-20-21.404.302.041.152.6798.300.772.160.010.82 a,b2.48
400-10-20-31.664.262.021.393.38106.480.982.830.011.02 a,b2.70
Table 5. Numerical results on the large-scale instance set T l , relative to the lower bound. The values marked with letters indicate the GDDR significantly outperforms different benchmark algorithms at 5% significant level, where “a”, “b”, and “c” represent the GDSPT, IDE, and RDE algorithms, respectively. Run time of GDSPT is omitted because it finishes all instances within a second.
Table 5. Numerical results on the large-scale instance set T l , relative to the lower bound. The values marked with letters indicate the GDDR significantly outperforms different benchmark algorithms at 5% significant level, where “a”, “b”, and “c” represent the GDSPT, IDE, and RDE algorithms, respectively. Run time of GDSPT is omitted because it finishes all instances within a second.
GDSPTIDERDEGDDR
n-m-b-hAvg (%)Max (%)Time (s)Avg (%)Max (%)Time (s)Avg (%)MaxTime (s)Avg (%)Max (%)
600-10-10-24.557.924.144.227.04478.533.725.870.021.42 a,b,c2.40
600-10-20-21.442.191.931.372.19321.060.821.880.010.69 a,b,c1.23
600-20-10-23.587.153.793.566.95406.823.255.300.011.72 a,b,c3.34
600-20-20-21.342.901.881.222.57341.800.611.720.010.61 a,b,c1.33
900-10-10-23.9510.3711.843.819.62613.623.629.120.041.27 a,b,c3.13
900-10-20-21.762.855.931.702.85584.911.512.850.020.71 a,b,c1.17
900-20-10-24.588.9711.674.297.41613.894.036.830.031.48 a,b,c2.54
900-20-20-21.653.495.881.552.96584.991.242.190.020.86 a,b,c1.70
1200-10-10-26.1414.1026.795.4313.16638.085.0812.330.061.90 a,b,c6.12
1200-10-20-21.793.4013.511.763.40621.511.673.400.030.69 a,b,c1.18
1200-20-10-25.1210.4526.814.488.08643.894.167.780.041.21 a,b,c2.49
1200-20-20-21.582.7912.931.512.08616.201.441.950.020.80 a,b,c1.15
Table 6. Absolute mean performance differences of the GPs based on 50 runs.
Table 6. Absolute mean performance differences of the GPs based on 50 runs.
BSGPBatchCCGPGDDR-CCGP
BFGP−686,434.96 (+)453,248.68 (+)414,854.98 (+)
BSGP 1,139,683.64 (+)1,101,289.94 (+)
BatchCCGP −38,393.70 (o)
Table 7. Overall improvement ratio and dominant ratio of GPs compared with benchmark algorithms.
Table 7. Overall improvement ratio and dominant ratio of GPs compared with benchmark algorithms.
Improvement Ratio (%)Dominant Ratio (%)
GDSPTIDERDEGDSPTIDERDE
AvgBestAvgBestAvgBestAvgBestAvgBestAvgBest
BSGP41.45−31.1760.99−23.1979.14−13.0450.1393.4839.4882.6130.2665.22
BFGP−16.43−22.48−4.81−11.3910.343.1087.22100.0056.2665.2250.3558.70
BatchCCGP−29.16−37.90−19.43−29.66−8.39−19.6892.17100.0080.3093.4863.2676.09
GDDR-CCGP−27.68−40.25−17.89−32.20−6.81−22.7490.65100.0080.0993.4861.9178.26
Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Share and Cite

MDPI and ACS Style

Liu, L.; Shi, L. Automatic Design of Efficient Heuristics for Two-Stage Hybrid Flow Shop Scheduling. Symmetry 2022, 14, 632. https://doi.org/10.3390/sym14040632

AMA Style

Liu L, Shi L. Automatic Design of Efficient Heuristics for Two-Stage Hybrid Flow Shop Scheduling. Symmetry. 2022; 14(4):632. https://doi.org/10.3390/sym14040632

Chicago/Turabian Style

Liu, Lingxuan, and Leyuan Shi. 2022. "Automatic Design of Efficient Heuristics for Two-Stage Hybrid Flow Shop Scheduling" Symmetry 14, no. 4: 632. https://doi.org/10.3390/sym14040632

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop