A Computational Study of Representations in Genetic Programming to Evolve Dispatching Rules for the Job Shop Scheduling Problem

IEEE TRANSACTIONS ON EVOLUTIONARY COMPUTATION, VOL. 17, NO. 5, OCTOBER 2013 621

A Computational Study of Representations inGenetic Programming to Evolve Dispatching Rules

for the Job Shop Scheduling ProblemSu Nguyen, Mengjie Zhang, Senior Member, IEEE, Mark Johnston, Member, IEEE,

and Kay Chen Tan, Senior Member, IEEE

Abstract—Designing effective dispatching rules is an importantfactor for many manufacturing systems. However, this time-consuming process has been performed manually for a very longtime. Recently, some machine learning approaches have beenproposed to support this task. In this paper, we investigate theuse of genetic programming for automatically discovering newdispatching rules for the single objective job shop schedulingproblem (JSP). Different representations of the dispatching rulesin the literature are newly proposed in this paper and arecompared and analysed. Experimental results show that therepresentation that integrates system and machine attributes canimprove the quality of the evolved rules. Analysis of the evolvedrules also provides useful knowledge about how these rules caneffectively solve JSP.

Index Terms—Dispatching rule, genetic programming,hyper-heuristic, job shop scheduling (JSP).

I. Introduction

IN THE FIELD of sequencing and scheduling, job shopscheduling is one of the most popular problems because of

its complexity and applicability in real-world situations. In thejob shop scheduling problem (JSP), given a set of machinesand a set of jobs with various predetermined routes throughthe machines, the objective is to find the schedule of jobsthat minimizes certain criteria such as makespan, maximumlateness, total weighted tardiness, etc. Different approacheshave been proposed to solve this problem and they can beclassified into two main categories [1]: 1) theoretical studiesof optimization methods that are usually restricted to staticproblems, and 2) experimental studies of heuristics or dis-patching rules to deal with both static and dynamic problems.

Manuscript received May 24, 2012; revised October 9, 2012; acceptedOctober 20, 2012. Date of publication November 16, 2012; date of currentversion September 27, 2013. This work was supported in part by the MarsdenFund of the New Zealand Government under Grants VUW0806 and 12-VUW-134 administrated by the Royal Society of New Zealand, and the UniversityResearch Fund, under Grant 200457/3230, at the Victoria University ofWellington.

S. Nguyen, M. Zhang, and M. Johnston are with the Evolution-ary Computation Research Group, Victoria University of Wellington,Wellington 6012, New Zealand (e-mail: [email protected];[email protected]; [email protected]).

K. C. Tan is with the Department of Electrical and Computer En-gineering, National University of Singapore, 117576, Singapore (e-mail:[email protected]).

Color versions of one or more of the figures in this paper are availableonline at http://ieeexplore.ieee.org.

Digital Object Identifier 10.1109/TEVC.2012.2227326

Although the dispatching rules do not guarantee to provideoptimal solutions for the problems, they have been appliedextensively in research and practice because of their simplicityand ability to cope with the dynamic environment. Differentfrom optimization approaches that represent the schedulingsolution in a very sophisticated way in order to employspecialized techniques to solve the scheduling problem, adispatching rule provides a way to perform a scheduling taskwhich is understandable to shop floor operators. Normally, adispatching rule is considered a simple function that deter-mines the priorities of jobs in the queue of a machine anddecides which one should be processed next. The popularity ofthe dispatching rule is derived from the fact that it can be easilymodified when real-world aspects such as setup time, releasetime, or parallel machines are considered. Another aspect thatmakes dispatching rules attractive to both researchers andpractitioners is that they do not have the scalability problemswhich are a big issue of almost all optimization methods.Moreover, effective dispatching rules can also be used to creategood initial solutions for optimization methods.

Many studies have been done in order to discover neweffective dispatching rules. One of the most straightforwardways to improve the performance of dispatching rules withoutaffecting their simplicity is to use a combination of simpledispatching rules. Another way to employ different dispatchingrules is to monitor the status of jobs in the system and makea change from one dispatching rule to another as planned. Forexample, FIFO/SPT will apply first-in-first-out (FIFO) whenthe jobs in the queue of the considered machine have beenwaiting for more than a specific time and shortest-processing-time (SPT) will be applied otherwise. This combination, eventhough very simple, can take advantage of each rule at properdecision making moments and is normally better than theapplication of a single dispatching rule. Another approach toimproving the performance of dispatching rules is to createcomposite dispatching rules (CDR) [2], [3] which provideheuristic combinations of simple rules basically in the formof sophisticated human-made priority functions of variousscheduling parameters (processing times, waiting times, etc.).

Although the combinations of different simple dispatchingrules may create better rules, the task of developing suchrules is complicated and time consuming. Recently, machinelearning methods have been proposed to facilitate this task.

1089-778X c© 2012 IEEE

622 IEEE TRANSACTIONS ON EVOLUTIONARY COMPUTATION, VOL. 17, NO. 5, OCTOBER 2013

Some genetic programming (GP) methods [4]–[10] have beenproposed to evolve dispatching rules. In these methods, theGP programs are used to calculate the priority of jobs inthe queue of each machine and the job with highest prioritywill be processed first. The experimental results showed thatthe dispatching rules evolved by GP can outperform simpledispatching rules. Li and Olafsson [11] applied a data miningtechnique to discover new dispatching rules based on pro-duction data. Data engineering was also considered in theirresearch in order to create more useful attributes besides theones recorded as part of the raw production data. The resultsshow that the discovered decision rules can accurately replicatethe dispatching list obtained by specific rules. Ingimundar-dottir and Runarsson [12] proposed a supervised learningapproach that tries to discover new dispatching rules usingthe characteristics of optimal solutions. The learned linearpriority dispatching rules showed better results than simplerules.

With its ability to evolve sophisticated rules and flexiblerepresentations, GP is a very promising method for auto-matically generating dispatching rules for the JSP. Moreover,if properly implemented, GP can evolve effective reusablerules to solve the JSP. This feature makes GP more attrac-tive than other evolutionary computation and meta-heuristicmethods where only a disposable solution is obtained for eachproblem instance. One of the key factors that can enhancethe performance of dispatching rules is the incorporation ofmachines and shop status into the rules in order to makemore informative sequencing decisions. Miyashita [8] pro-posed three models to evolve dispatching rules with GP andshowed that the two models which evolved different dedicateddispatching rules for different machines in the shop are betterthan the model which only employed a common dispatchingrule for all machines. One of the drawbacks with this methodis that evolving different dedicated dispatching rules wouldsignificantly increase the computational time of the proposedGP system and can also lead to overfitting problems [8].Another disadvantage is that the representation in these modelsrequired the specific knowledge of the environment which canbe changed in real situations. For that reason, it is very difficultto create more generalized and effective rules to deal withsuch a complicated problem as JSP. Jakobovic and Budin [6]proposed a more dynamic method to incorporate machineattributes into the evolved dispatching rules. Their proposedGP-3 system evolved three components, including two dis-patching rules and a discrimination function to determinewhich dispatching rule the considered machine should employbased on the attributes of that machine. The results showedthat GP-3 was better than the GP method that only evolveddispatching rules. Unfortunately, no analysis or description ofthe evolved dispatching rules were provided in the paper. Itshould be noted that these existing studies emphasized notonly the importance of machine attributes in the evolved rulesbut also the importance of how to embed these attributes intothe evolved dispatching rules. Although some GP systems forevolving dispatching rules have been proposed, no detailedcomparison and analysis of those representations have beendone, which is an important issue in GP.

In this paper, we use GP to evolve adaptive dispatchingrules (ADR) for the static JSP with makespan and totalweighted tardiness as objective functions. Basically, an ADR isa combination of different dispatching rules and it is adaptivebecause the master rule will choose a specific dispatchingrule to sequence jobs in the queue based on the status of themachines at each decision making step. Three representationsof dispatching rules are proposed and tested with the GPsystem. The objectives of this paper are to: 1) investigatethe performance of the GP system with different types ofrepresentations; 2) compare the performance of the evolvedrules with well-known dispatching rules both on the trainingset and test set; and 3) analyze the performance of the proposedalgorithm as well as the evolved rules and compare evolvedrules with improvement heuristics.

The remainder of this paper is organized as follows. Inthe next section, the background of JSP and heuristic gen-eration methods is given. Section III will provide a detaileddescription of the proposed method. The experimental settingis presented in Section IV and the results will be shownin Section V. Some insights regarding the proposed methodand the evolved rules will be discussed further in SectionVI. Section VII offers some conclusions and future researchdirections.

II. Background

This section provides a brief review of JSP and hyper-heuristic (HH) methods for heuristic generation which pro-vides essential background for later sections.

A. Job Shop Scheduling Problem

This paper concentrates on minimization of the makespanand total weighted tardiness, known as Jm||Cmax andJm|| ∑wjTj in the JSP literature. In this case, the shopincludes a set of M machines and N jobs that need to bescheduled. Each job j has its own predetermined route througha sequence of machines to follow and its own processing timeat each machine it visits. In this paper, jobs are only allowedto visit a machine at most once; and therefore no recirculationcan occur. Some basic definitions and notations are presentedbelow that will be used in the rest of this paper.Parameters:

1) Oj = {oj,1, . . . , oj,l, . . . , oj,Nj}: the set of all operations

of job j where oj,l, is the lth operation of job j and Nj

is the number of operations of job j;2) wj: the weight given to job j in the weighted tardiness

objective function;3) dj: the due date assigned to job j;4) p(σ): the processing time of operation σ;5) m(σ): the machine that processes operation σ;6) next(σ): the next operation of the job that contains σ or

null if σ is the last operation of that job (if σ = oj,l thennext(σ) = oj,l+1).

Variables:1) Rk: the ready time of machine k, which is the time that

the machine becomes idle; in this paper, all machinesare idle at the beginning;

NGUYEN et al.: STUDY IN GENETIC PROGRAMMING TO EVOLVE DISPATCHING RULES 623

Fig. 1. Generic procedure to construct a schedule for JSP.

2) r(σ): the ready time of operation σ, which is the releasetime of job j (the time that job j is allowed to start,considered to be zero in all instances in the experiments)for the first operation or the completion time of itspreceeding operation for other operations;

3) Cj: the completion time of job j. Makespan Cmax =max(C1, . . . , CN );

4) Tj: the tardiness of job j and Tj = max(Cj − dj, 0). Thetotal weighted tardiness is

∑wjTj .

1) Active Schedules and Nondelay Schedules: In JSP, aschedule is called active if it cannot be altered to make someoperations complete earlier without delaying the completiontime of other operations. Active schedules were first proposedby Giffler and Thompson [13] in their seminal work and it hasbeen proven that an optimal solution to JSP must be an activeschedule. Schedules where no machine is allowed to be idlewhen there are jobs in the queue are called nondelay schedules.A nondelay schedule is more restricted than an active scheduleand the set of nondelay solutions may not include the optimalsolution. Nondelay schedules are often applied in experimentsusing simulation since a machine will immediately processall jobs in its queue in the order determined by a specificsequencing rule.

Fig. 1 shows a generic procedure to construct an activeschedule, a nondelay schedule or a hybrid of both activeand nondelay schedules. In this procedure, � contains allthe operations that are ready to be scheduled. The procedurewill first determine the next operation that would completefirst if scheduled and the corresponding machine m∗ (ties arebroken arbitrarily). The nondelay factor α ∈ [0, 1] controlsthe look ahead ability of the algorithm and decides whichjobs should be considered by the dispatching rule �. If α = 0,the procedure can only construct nondelay schedules and onlyoperations that have already joined the queue are consideredfor scheduling. On the other hand, if α = 1, the procedure willconsider all the potential jobs that are ready to join the queueof machine m∗ before the earliest completion time of m∗. Ingeneral, α determines the interval of time that a machine isallowed to wait even when there are operations in the queue.As a result, there are fewer operations to be considered in eachstep of the algorithm when α is small.

2) Job Shop Scheduling Techniques: Over the last fewdecades, a large number of techniques have been applied toJSP, ranging from simple heuristics to artificial intelligenceand mathematical techniques [14]. Because of the complexityof JSP, finding optimal solutions can be very time-consuming,particularly for large and complex shops. The research onmeta-heuristics approaches for scheduling has been very activein the last two decades, mostly with makespan as the objectivefunction, i.e., Jm||Cmax. Local search based approaches suchas large step optimization [15], tabu search [16], and guidedlocal search [17] have shown very promising results in solvingthe static JSP. The focus of these approaches is on the devel-opment of efficient neighborhood structures and diversifyingstrategies to escape from local optima. Since neighborhoodstructures play an important role in these approaches, theneighborhood structures and their related operators have tobe redesigned in order to incorporate real-world constraints;even then it is still questionable whether they produce superiorresults.

A more general alternative for solving JSP is the use ofevolutionary computation methods. Genetic algorithm (GA) isone of the most popular approaches in this line of research(refer to [18] for a review of GA approaches for JSP).Besides Jm||Cmax, research on other objective functions hasalso been considered in the literature, especially due daterelated objectives due to the need to improve the delivery per-formance in modern manufacturing systems. For Jm|| ∑wjTj ,several methods have been proposed in the literature andshown promising results. For example, Kreipl [19] proposed anefficient large step random walk (LSRW) method, which is stillone of the best local search methods to deal with Jm|| ∑wjTj .Zhou et al. [20] introduced a general framework using agenetic algorithm and heuristic rules to solve a similar problemand showed that it is better than the pure genetic algorithm.Even though the proposed hybrid GA provides solutions thatare inferior to those obtained by LSRW [19], it is still verypromising since it is capable of solving a variety of schedulingproblems without major redesign.

Although there have been many breakthroughs in the de-velopments of exact and approximate approaches for JSP,these approaches are mainly focused on static problems andsimplified job shop environments. General approaches likeGA can be extended to solve problems with realistic con-straints, but the major drawback is its weak computationalefficiency. Moreover, as pointed out by McKay et al. [21],the conventional operational research and artificial intelligenceapproaches are often not applicable to the dynamic charac-teristics of the actual situation because these approaches arefundamentally based on static assumptions. For that reason,simple dispatching rules have been used consistently in prac-tice because of their ability to cope with the dynamics ofshop changes [22]. There have been a large number of rulesproposed in the literature and they can be classified into threecategories [14]: 1) simple priority rules, which are mainlybased on the information related to the jobs; 2) combinationsof rules that are implemented depending on the situation thatexists on the shop floor; and 3) weighted priority indices thatemploy more than one piece of information about each job to


determine the schedule. Composite dispatching rules (CDR)[2], [3] can also be considered a version of rules based onweighted priority indices, where scheduling information canbe combined in more sophisticated ways instead of linearcombinations.

B. Hyper-Heuristics for Heuristic Generation

Hyper-heuristics are a new search method and have attracteda lot of attention from the research community. A HH is anautomated methodology for selecting or generating heuristicsto solve hard computational search problems [23]. Heuristicselection and heuristic generation are currently the two mainresearch methodologies in HH [24]. The focus of this paperis on HH for heuristic generation. In order to generate a newheuristic, the HH framework must be able to combine varioussmall components, normally common statistics or operatorsused in preexisting heuristics, and these heuristics are trainedon a training set and evolved to become more effective.

1) Genetic Programming Based Hyper-Heuristics (GP-HH): Recently, GP has become popular in the field of HHand it is known as genetic programming based hyper-heuristics(GP-HH) [25]. Because GP is able to represent and evolvecomplex programs or rules, it naturally becomes an excellentcandidate for heuristic generation. Bolte and Thonemann [26]proposed a GP system to evolve annealing schedule functionsin simulated annealing to solve the quadratic assignment prob-lem (QAP). The experimental results showed that the methodwith GP as a meta-algorithm can find near optimal solutionsfor QAP. Fukunaga [27] used GP to evolve variable selectionheuristics in each application of a local search algorithmfor the satisfiability (SAT) problem and showed competi-tive results when compared with other heuristics. Bader-El-Den and Poli [28] also employed GP to evolve disposablelocal search heuristics to solve SAT for a specific set ofinstances and the evolved heuristics show very competitiveresults as compared to other well-known evolutionary or localsearch heuristics. Burke et al. [29], [30] proposed a GP-HHframework to evolve construction heuristics for online binpacking. The basic idea of this GP system is to generatea priority function from static and dynamic statistics of theproblem to decide where the considered pieces should beplaced. The experimental results showed that human designedheuristics can be obtained by GP. A similar idea was alsoapplied to evolve 2-D strip packing heuristics and showedvery good results [31]. Keller and Poli [32], [33] proposeda grammar-based linear GP method to solve the travelingsalesman problem. Several grammars are introduced, includ-ing ones with a looping construct. Bader-El-Den et al. [34]introduced a sophisticated grammar-based GP for evolvingtimetabling heuristics. The evolved heuristics were able toproduce competitive results when compared with some ex-isting search methods in the literature. Burke et al. [35]proposed a grammatical evolution method for automatic designof local search heuristics for cutting and packing problems.The experimental results showed the competitiveness of theevolved local search heuristics.

2) GP-HH for Scheduling Problems: Dimopoulos andZalzala [36] used GP to evolve reusable dispatching rules for

the one-machine scheduling problem with a standard functionset and a terminal set of scheduling statistics (processing time,release time, due date, number of jobs, etc.). The evolveddispatching rules were found to be better than traditionalrules and these rules can be reused for a range of unseenproblem instances. The best evolved rules were also examinedand the analysis showed that these rules are interpretable.Jakobovic et al. [37] employed the same method for devel-oping dispatching rules for the parallel machine schedulingproblem in both static and dynamic environments. However,the evolved rules obtained from these studies have not consid-ered the effects of different representations on the performanceof the GP system and the machine and system attributes werenot included in the evolved rules. Also, trying to learn newdispatching rules for the single machine environment, Geigeret al. [38] presented a learning system that combines GP witha simulation model of an industrial facility. The proposedGP system is used to create the priority rule for a singlemachine in static and dynamic environments. The terminal setof GP includes system attributes, job attributes, and machineattributes, and the function set consists of basic operators. Thepaper also proposed a method to learn dispatching rules formultiple machine problems in which GP will evolve multipletrees simultaneously with modified crossover and mutationoperators. Comparison with the optimal rule in a simple twomachine environment showed that the evolved rules are quitecompetitive. However, the use of an independent dispatchingrule for each machine may rapidly increase the complexityof the scheduling systems and make it difficult to generategeneralized rules for large manufacturing systems. Geiger andUzsoy [39] also applied this system for learning dispatchingrules for batch processor scheduling, with very promisingresults. For a stochastic single machine scheduling problem,Yin et al. [40] proposed a GP system employing a bi-tree struc-tured representation scheme to deal with machine breakdowns.The empirical results under different stochastic environmentsshowed that GP can evolve high quality predictive schedulingheuristics.

Miyashita [8] developed an automatic method using GP todesign customized dispatching rules for a job shop environ-ment and viewed JSP as a model of a multiagent problemwhere each agent represents a resource (machine or workstation). Three multiagent models are proposed: 1) a homoge-neous model where all resources share the same dispatchingrule; 2) a distinct agent model where each resource employsits own evolved rule; and 3) a mixed agent model where tworules can be selected to prioritize jobs depending on whetherthe resource is a bottleneck or not. Although the multiagentmodels perform better, the use of these models depends on thesome prior-knowledge of the job shop environment, which canbe changed in dynamic situations. A similar system was alsoproposed by Atlan et al. [41] but the focus of their paperis on finding the solution for a particular problem instance.Jakobovic and Budin [6] applied GP to evolve dispatchingrules for both single machine and job shop environments.The results for the single machine environment are shown tobe better than existing rules. For the job shop environment,a meta-algorithm is defined to show how the evolved rules


are used to construct a schedule. This paper also proposedan interesting way to provide some adaptive behaviors forthe evolved rules. They proposed a GP-3 system that evolvesthree components, a discriminant function and two dispatchingrules. The discriminant function aims at identifying whetherthe considered machine to be scheduled is a bottleneck or not.This function serves as the classifier in binary classificationproblems. Based on the classification decision obtained fromthe discriminant function, one of two dispatching rules will beselected to sequence jobs in the queue of that machine. Eventhough the purpose of the discriminant function in this case isto identify the bottleneck machine, there is no guarantee thatthe classification can help indicate the bottleneck machine orjust some useful attributes of the shop or machines. The resultsshow that the GP-3 system performed better than traditionalGP with a single tree. Unfortunately, no demonstrations oranalyses of the evolved rules are given. Tay and Ho [5] pro-posed a GP system to evolve dispatching rules for a job shopenvironment. The proposed GP program can be considered asa priority function which is used to calculate the priority ofoperations in the queue of a machine. The set of instanceswas randomly generated and it was shown that the evolveddispatching rules can outperform other simple dispatchingrules. However, they did not consider the use of machineattributes in the priority function. Hildebrandt et al. [7]re-examined the GP system proposed in [5] in different dy-namic job shop scenarios and showed that rules evolved by Tayand Ho [5] are only slightly better than the earliest release date(ERD) rule and quite far away from the performance of theSPT rule. They explained that the poor performance of theserules is caused by using the linear combination of differentobjectives and the fact that the randomly generated instancescannot effectively represent the situations that happened in along term simulation. For that reason, Hildebrandt et al. [7]evolved dispatching rules by training them on four simulationscenarios (10 machines with two utilization levels and twojob types) and only aimed at minimising the mean flow time.Some aspects of the simulation models were also discussedin their study. The experimental results indicated that theevolved rules were quite complicated but effective whencompared to other existing rules. Moreover, these evolvedrules are also robust when tested with another environment(50 machines and different processing time distributions).Pickardt et al. [42] applied this system to evolve dispatchingrules for semiconductor manufacturing to minimize weightedtardiness. Vazquez-Rodriguez and Ochoa [43] proposed a GPsystem to learn variants of the Nawaz, En-score, and Ham(NEH) procedure for flow shop scheduling. The results showedthat the evolved heuristics can outperform the original andstochastic variants of NEH.

Other methods have also been proposed for generating newdispatching rules. Li and Olafsson [11] applied data miningtechniques on production data to generate dispatching rules.For further improvement, the authors used data engineering tocreate more useful attributes besides ones recorded as part ofthe raw production data. The results show that the decisionrules discovered can accurately replicate the dispatching listobtained by specific rules. However, since the rules are learned

from the historical records of the production system, it isdifficult to generate new dispatching rules and the performanceof the evolved rules may only be as good as the actual rules.Most recently, Ingimundardottir and Runarsson [12] proposeda supervised learning approach that tries to discover newdispatching rules using the characteristics of optimal solutions.The learned linear priority dispatching rules showed betterresults than simple rules. One of the drawbacks is that theproposed supervised learning approach tries to learn from theoptimal solutions which are not available in many cases.

Dispatching rules have been a very practical tool forscheduling in real world situations. However, manual design ofnew dispatching rules is still a very time consuming process.Several machine learning methods have been proposed to easethis task. GP is one of the most popular methods becauseof its flexibility which helps it easily cope with differentproblem environments. Since the design process is automatedby GP, not only priority functions but also complicated issuessuch as incorporating machine and system attributes can beconsidered in order to improve the effectiveness of evolvedrules. However, the existing GP systems mainly focus onlyon evolving priority functions. Also, bottleneck was the onlysystem attribute used in the previous studies [6], [8]. Inthis paper, we propose two new representations for GP thatevolve rules with the ability to incorporate different machineand system attributes to make better sequencing decisions. Acomparison between the proposed rules and the arithmeticrepresentation used in previous studies is also presented.This paper also examines other important issues, such as theinfluence of fitness functions and analysis of evolved rules,to gain more understanding of how GP can evolve effectivedispatching rules.

III. Methodology

This section discusses a new GP system that is able tolearn new dispatching rules which can adaptively sequenceoperations in the queue based on the status of the shop and themachines to be scheduled. In this section, the representationsof a dispatching rule are presented first, followed by thefitness function used to measure the performance of an evolveddispatching rule.

A. Representations

Three representations of dispatching rules are consideredin this paper. The first representation (R1) provides a way toincorporate machine attributes into the GP program along withsimple dispatching rules and the hybrid scheduling strategybetween nondelay and active scheduling. The second repre-sentation (R2) is the traditional arithmetic representation likethat employed in [5]; the purpose of this representation is togenerate composite dispatching rules. The last representation(R3) is a combination of R1 and R2, in which differentcomposite dispatching rules exist and are logically applied toJSP based on the machine and system attributes.

1) Decision-Tree Like Representation (R1): The key ideaof this representation is to provide the adaptive dispatchingrules the ability to apply different simple dispatching rules


Fig. 2. Grammar for the proposed GP system with R1.

Fig. 3. Example program trees based on representation R1. (a) SPT withα = 0.084. (b) If (WR ≤ 20%) then use SPT with α = 0.221 else use FIFOwith α = 0.078.

based on machine attributes. In this case, the adaptive dis-patching rules are represented in a decision-tree form. Tomake the rules more readable and explainable, the proposedgrammar in Fig. 2 is used when building the GP programsand performing the genetic operators (e.g., dispatching nodesmust contain two arguments, which are a value of the nondelayfactor and a single dispatching rule). Two example rules basedon this grammar are shown in Fig. 3. In Fig. 3(a), the rule issimilar to that of SPT which is applied with the nondelay factorα = 0.084. The rule in Fig. 3(b) is a bit more sophisticated.The rule firstly checks the workload ratio WR (the ratio ofthe total processing times of jobs in the queue to the totalprocessing times of all jobs that have to be processed at themachine) of the considered machine m∗; if the workload ratiois less than or equal to 20%, dispatching rule SPT is appliedwith α = 0.221; otherwise, dispatching rule FIFO is appliedwith α = 0.078. This ADR can be considered as a variant ofFIFO/SPT, in which the workload of the machine is used asthe switch instead of the waiting times of jobs in the queue.Different from other applications [44], [45] where a singlenondelay factor is evolved, the proposed GP system using thisrepresentation allows different values of nondelay factors tobe employed based on the status of the shop.

In this paper, we will consider six attributes that indicatethe status of machines in the shop. Let � be the set ofoperations that are planned to visit the considered machinem∗, and K and I are the sets of all operations that have andhave not yet been processed by m∗, respectively (� = K ∪ I).In the shop, we call a machine critical if it has the greatest

total remaining processing time∑

σ∈I p(σ) and a machine iscalled bottleneck if it has the largest workload

∑σ∈�′ p(σ)

in �′. The following definitions of the machine and systemattributes are used in this paper.

1) Workload ratio, WR =∑

σ∈�′ p(σ)∑

σ∈I p(σ) : this indicates the work-load in �′ compared to the total remaining workload thatm∗ has to process (including the operations in the queueand operations that have not yet visited m∗).

2) Machine progress, MP =∑

σ∈K p(σ)∑

σ∈� p(σ) : this indicates theprogress of m∗, calculated as the ratio of the totalprocessing time that m∗ has processed to the total pro-cessing time of all operations in �′ that have to visit m∗.

3) Deviation of jobs, DJ = minσ∈�′ {p(σ)}maxσ∈�′ {p(σ)} : this is a simple

ratio of minimum processing time to the maximumprocessing time of operations in �′.

4) Critical machine idleness, CMI: this is the workloadratio WR of the critical machine.

5) Critical workload ratio, CWR =∑

σ∈�c p(σ)∑

σ∈�′ p(σ : this isthe ratio of the workload of operations in �c to theworkload in �′ where �c ⊂ �′ is the set of operationsbelonging to the jobs that have operations that stillneed to be processed at the critical machine after beingprocessed at m∗.

6) Bottleneck workload ratio, BWR =∑

σ∈�b p(σ)∑

σ∈�′ p(σ) : this is

the ratio of the workload of operations in �b to theworkload in �′ where �b ⊂ �′ is the set of operationsbelonging to the jobs that have operations that still needto be processed at the bottleneck machine after beingprocessed at m∗.

While the first three attributes provide the local status atm∗, the last three attributes indicate the status of the shop witha special focus on the critical and bottleneck machines. Themachine and system attributes here appear in the schedulingliterature in different forms. The key difference between ourattributes and the attributes used in other studies is that our at-tributes have been scaled from 0 to 1. The scaled (normalized)attribute values aim to enhance the generality of the evolvedrules and also make the evolved rules easier to understand.Jakobovic and Budin [6] employed attributes similar to ourswithout normalization (e.g. remaining work at the machineis similar to workload ratio in this paper). The definitionof attributes for bottleneck and critical machines are adaptedfrom the bottleneck concept [46] for static problems and theseattributes are used to adjust the rules to react appropriately tothe changes of the shop.

For representation R1, eleven simple dispatching rules areconsidered as the candidate rules in the ADR. The aim ofthese rules is to determine which operation σ in �′ will beprocessed next. Let n(σ) be the job which operation σ belongsto, j = n(σ) and oj,h = σ. The following are brief descriptionsof the candidate dispatching rules. Detailed discussion of theserules can be found in [1] and [47].

1) FIFO: operations are sequenced first-in-first-out.2) SPT : select the operation with the shortest processing

time p(σ).3) LPT : select the operation with the longest processing

time p(σ).


TABLE I

Terminal Set for R2 (j = n(σ) and oj,h = σ )

Notation Description ValueRJ Operation ready time r(σ)RO Number of remaining operations of job j Nj − h + 1

RT Work remaining of job j∑Nj

l=h p(oj,l)PR Operation processing time p(σ)W Weight wj

DD Due date dj

RM Machine ready time Rm∗

# Constant Uniform[0, 1]

4) LSO: select the operation belonging to the job that hasthe longest subsequent operation p(next(σ)).

5) LRM: select the operation belonging to the job that hasthe longest remaining processing time (excluding theoperation under consideration)

∑Nj

l=h+1 p(oj,l).6) MWKR: select the operation belonging to the job that

has the most work remaining∑Nj

l=h p(oj,l).7) SWKR: select the operation belonging to the job that has

the smallest work remaining∑Nj

l=h p(oj,l).8) MOPR: select the operation belonging to the job that has

the largest number of operations remaining Nj − h + 1.9) EDD: select the operation belonging to the job that has

the earliest due date dj .10) MS: select the operation belonging to the job that has

the minimum slack MSj = dj − ∑Nj

l=h p(oj,l) − t. Valuet = Rm∗ is the time at which the sequencing decisionneeds to be made.

11) WSPT : select the operation that has the maximumweighted shortest processing time wj/p(σ).

The nondelay factor is treated as Ephemeral Random Con-stants (ERC) [48]. The values of the nondelay factor willinitially be a random number from 0 to 1. Meanwhile, attributetype, attribute threshold and dispatching rule terminals arerandomly chosen from their candidate values as described inthe previous section with equal probabilities.

2) Arithmetic Representation (R2): For this representation,the focus is to formulate composite dispatching rules that in-clude different pieces of information from jobs and machines.Basically, the GP programs are priority functions that can beused to calculate the priorities for operations in �′ and theoperation with the highest priority will be scheduled to beprocessed next on the machine m∗. Different from R1 rules thatbecome more effective by logical choices of single dispatchingrules, R2 rules create their sophisticated behavior arithmeti-cally combining various terms into the priority functions. Theadvantage of this representation is that more information canbe directly considered to determine the priorities of operationswhen sequencing decisions need to be made.

In our GP system, the four basic arithmetic operators(+, −, ∗, protected division %) are used in the function set.Since we evolve a function to prioritize operations, it seemsuseful to include a single-argument function (−1∗) in thefunction set to provide a more convenient way to createpriority functions. The terminal set contains popular termsthat are used in developing existing dispatching rules. The

Fig. 4. Example program trees based on representation R2. (a) W%PR. (b)(RT + RM) − DD.

Fig. 5. Example program tree based on representation R3.

descriptions of the terminals used for calculating the priorityof operation σ are shown in Table I. Fig. 4 shows two simpleexamples when WSPT and MS are represented by R2 rules.The nondelay scheduling strategy will be used along withthis representation like common applications of compositedispatching rules.

3) Mixed Representation (R3): This representation tries tocombine the advantages of R1 and R2 to create sophisticatedadaptive dispatching rules. Within R3, the incorporation ofboth system/machine status and composite dispatching rulesare considered. The representation R3 inherits the grammarin R1 and the composite dispatching rules will be used tocalculate the priorities of operations for sequencing decisionsbesides the use of simple dispatching rules. An example of anR3 rule is shown in Fig. 5.

B. Fitness Evaluation

The focus of this paper is to learn effective rules for JSP tominimize the makespan or total weighted tardiness. In order toestimate the effectiveness of an evolved dispatching rule, it willbe applied within the construction procedure in Fig. 1 to solvea set of instances in the training set and the resulting objectivevalues from all instances are recorded. Since the objectivevalues obtained by a dispatching rule � for each instance arevery different, we will measure the quality of an obtainedschedule by the relative deviation of its objective value fromits corresponding reference objective value as shown in (1)

dev(�, In) =Obj(�, In) − Ref (In)

Ref (In). (1)

In this equation, Obj(�, In) is the objective value obtainedwhen applying rule � to instance In, and Ref (In) is thereference objective value for instance In. The fitness of rule� on the training set is calculated by (2). The fitness functiondevaverage(�) will measure the average performance of �


Fig. 6. GP algorithm to evolve dispatching rules for JSP.

across T instances in the data set

devaverage(�) =

∑In∈{I1,...,IT } dev(�, In)

T. (2)

The objective of the GP system is to minimize this fitnessfunction. In the case of Jm||Cmax, the reference objective valueis the lower bound obtained by other approaches (refer to[49] for a list of lower bound values obtained for popularbenchmark instances). Since lower bounds are used in thiscase, the fitness values for the GP programs are alwaysnonnegative. If the fitness value is close to zero, it indicatesthat the evolved rules can provide near optimal solutions. ForJm|| ∑wjTj , because the lower bound values are not availablefor all instances, we will use objective values obtained byEDD using nondelay scheduling as the reference objectivevalues for all instances in the data set since it is a widely useddispatching rule for due date related problems. Because EDDis just a simple rule, it can be dominated by more sophisticatedrules. For that reason, the fitness value of the GP programs forJm|| ∑wjTj can be negative, which means that the evolvedrules perform better than EDD with a given fitness function.

C. Proposed GP Algorithm

Fig. 6 shows the GP algorithm used in this paper to evolvedispatching rules for JSP. The GP system first sets up thetraining set D and randomly initializes the population. Ata generation, each dispatching rule or individual �i will beapplied to solve all instances in the training set D to findthe relative deviation dev(�i, In) for each instance. Then, thefitness value of each rule is calculated by using devaverage(�i).If the evaluated rule is better and has smaller fitness valuethan the best rule �∗, it will be assigned to the best rule�∗ and the best fitness value fitness(�∗) is also updated.After all individuals in the population are evaluated, the GP

TABLE II

Parameters of the Proposed GP System

Population Size 1024Crossover rate 95%, 90%, 85%Mutation rate 0%, 5%, 10%Reproduction rate 5%Generations 50Max-depth 6Function set (R1) If, Dispatch, ≤,>Terminal set (R1) attribute type, attribute threshold, nondelay

factor, dispatching ruleFunction set (R2) +, −, ∗, %, (−1∗)Terminal set (R2) as shown in Table IFunction set (R3) Function set (R1) and Function set (R2)Terminal set (R3) Terminal set (R1) and Terminal set (R2)Fitness devaverage(�)

system will apply genetic operators such as reproduction(elitism), crossover, and mutation to the programs in thecurrent population to generate new individuals for the nextgeneration. More details of the genetic operators used in thispaper will be provided in the next section. When the maximumnumber of generations is reached, the GP algorithm will stopand return the best found rule �∗, which will be applied tothe test set to evaluate the performance of the GP system.

IV. Design of Experiments

This section discusses the configuration of the GP systemand the data sets used for training and testing.

A. Parameter Setting

The GP system for learning ADRs is developed based onthe ECJ20 library [50], a Java-based evolutionary computationresearch system. The parameter settings of the GP system usedin the rest of this paper are shown in Table II. The populationsize of 1024 is used to ensure that there is enough diversity inthe population. The initial GP population is created using theramped-half-and-half method [48]. Since the rules are createdbased on the grammar in Fig. 2, we use strongly typed GPto ensure that the GP nodes will provide proper return typesas determined by the grammar. In this case, the crossoverand mutation operators of GP are only allowed if they donot violate the grammar. For crossover, the GP system usesthe subtree crossover [48], which creates new individuals forthe next generation by randomly recombining subtrees fromtwo selected parents. Meanwhile, mutation is performed bysubtree mutation [48], which randomly selects a node of achosen individual and replaces the subtree rooted by that nodeby a newly randomly generated subtree. The combinations ofthree levels of crossover rates and mutation rates will be testedin our experiments to examine the influence of these geneticoperators on the performance of GP. When generating randominitial programs or applying crossover/mutation, the maximumdepth of six is used to restrict the program from becoming toolarge. Greater maximum depths can also be used here to extendthe search space of GP; however, we choose this maximumdepth to reduce the computational times of the GP system and


TABLE III

JSP Data Sets

Data Set Notation No. of Instances Problem Size (N × M) ReferenceLA la01-la40 40 From 10 × 5 to 15 × 15 Lawrence [51]ORB orb01-orb10 10 10 × 10 Applegate and Cook [52]TA ta01-ta80 80 From 15 × 15 to 100 × 20 Taillard [53]DMU dmu01-dmu80 80 From 20 × 15 to 50 × 20 Demirkol et al. [54]

make the evolved rules easier to analyse. Tournament selectionwith the tournament size of seven is used to select individualsfor genetic operations.

B. Data Sets

There are many data sets in the JSP literature that aregenerated by different scheduling researchers [51]–[54] tomeasure the performance of different heuristic and optimiza-tion methods. The instances in these data sets are still veryuseful because they include a wide range of instances withdifferent levels of difficulty. Moreover, lower bounds for theseinstances are available and can be used to calculate the fitnessof the evolved dispatching rules as described in Section III-B.Descriptions of the data sets used for the experiments areshown in Table III. In this paper, we combine these data setsand distribute them into the training set and test set used by theproposed GP system. The training set and test set are createdto include halves of the instances of each individual data setin Table III. In particular, the training set will contain {la01,la03, . . . , la39}, {orb01, . . . , orb09}, { ta01, . . . , ta79},{dmu01, . . . , dmu79}. The other even index instances willbe included in the test set. This allows a fair distribution ofproblems with different instance sizes into both training setand test set. There are 105 instances in each of the trainingset and test set. For the case of Jm|| ∑wjTj , the due datesfor jobs in each instance will be generated (following Baker[55]) by a due date assignment rule

dj = rj + h ×Nj∑l=1

p(oj,l). (3)

The parameter h is used to indicate the tightness of due dates.We choose h = 1.3 for all instances in the training set and testset because it is the common value used in previous research[19], [20]. For the weights of jobs, we employ the 4 : 2 : 1 rulewhich has been used in [19] and [20]. This rule is inspiredby Pinedo and Singer [56] when their research showed that20% of the customers are very important, 60% are of averageimportance and the remaining 20% are of less importance. Forthat reason, in Jm|| ∑wjTj , the weights of 4 are assigned tothe first 20% of jobs, the next 60% are assigned a weight of2 and the last 20% of jobs are assigned a weight of 1.

V. Results

The proposed GP systems with different settings are nowapplied to evolve new dispatching rules. This section shows theresults obtained from the GP system with three representations,three levels of crossover/mutation rates, and two objective

values of JSP. In total, we need 3 × 3 × 2 = 18 experiments.For each experiment, 30 independent runs are performed withdifferent random seeds. Tables IV and V-A show the meansand standard deviations of fitness values of the best evolvedrules from each run obtained from all experiments on thetraining set and test set. The triple 〈c, m, r〉 indicates theGP parameters used in a specific experiment. For example,〈85, 10, 5〉 represents the experiment where the crossover rateis 85%, the mutation rate is 10% and the reproduction rateis 5%. All statistical tests discussed in this section are thestandard z-tests and they are considered significant if theobtained p-value is less than 0.05.1

A. Makespan

As shown in Table IV, the evolved rules based on R1

show a performance close to those obtained by R2 and R3

on the training set. It is also noted that the R1 rules evolvedwith higher mutation rates are significantly better than thoseevolved without lower mutation (all p-values < 0.0174)on the training set. Since R1 rules contain many possibleterminals higher mutation rates seem quite useful to improvethe performance of the GP system with the R1 representation.However, the performance of R1 rules are quite poor on thetest set. This indicates the overfitting issue of R1 rules whenlearning with the training set. The reason for this problemcomes from the fact that the candidate rules used in R1 aretoo simple, and therefore the rules have to depend strongly onthe machine and system status to provide better sequencingdecisions on the training instances. However, the overuse ofthe machine and system attributes make R1 rules less effectivewhen dealing with unseen instances in the test set.

Evolved R2 rules show a more consistent performance onboth the training set and test set. Different from R1, thestatistical tests indicate that the choice of GP parameters doesnot have significant influence (all p-values > 0.1434) whenR2 is used as the representation of the dispatching rule. Theseresults indicate that mutation is not really useful in this caseand the crossover operator is sufficient for the GP system toevolve good individuals. Since R2 provides only one way tosequence operations, the effectiveness is obtained by goodcombinations of different terms. Hence, they are also lessaffected when working with unseen instances like R1 rules.

Taking the advantages of R1 and R2, the evolved R3 rulesshow very promising performance. Different from R1, theincorporation of the machine and system attributes into theR3 rules are supported by better composite dispatching rules,

1Wilcoxon tests are also performed and the results from these tests areconsistent with those obtained z-tests.


TABLE IV

Performance of Evolved Rules for Jm||Cmax on Training Set and Test Set with Different Settings (mean ± standard deviation)

SettingR1 R2 R3

Training Testing Training Testing Training Testing〈95, 0, 5〉 0.188 ± 0.008 0.197 ± 0.007 0.181 ± 0.003 0.187 ± 0.004 0.183 ± 0.005 0.186 ± 0.005

devaverage(�) 〈90, 5, 5〉 0.181 ± 0.003 0.192 ± 0.005 0.181 ± 0.003 0.188 ± 0.005 0.181 ± 0.005 0.184 ± 0.006〈85, 10, 5〉 0.180 ± 0.003 0.191 ± 0.006 0.180 ± 0.003 0.188 ± 0.004 0.179 ± 0.005 0.184 ± 0.004

TABLE V

Relative Deviations Obtained by Evolved Rules and Other Rules for Jm||Cmax

RulesTraining Set Test Set

Min Mean Max Min Mean Max

FIFOActive 0.012 0.325 0.691 0.000 0.325 0.654

Nondelay 0.012 0.325 0.691 0.000 0.325 0.654

SPTActive 0.322 0.694 1.252 0.316 0.711 1.091

Nondelay 0.029 0.292 0.576 0.092 0.312 0.664

LRMActive 0.020 0.321 0.745 0.000 0.319 0.723

Nondelay 0.000 0.224 0.556 0.000 0.225 0.529

MWKRActive 0.047 0.323 0.736 0.000 0.328 0.713

Nondelay 0.000 0.253 0.590 0.000 0.254 0.584

�c1R1

0.000 0.173 0.448 0.000 0.192 0.525

�c2R1

0.000 0.174 0.428 0.000 0.183 0.479

Evolved�c1

R20.000 0.174 0.479 0.000 0.190 0.442

�c2R2

0.000 0.175 0.457 0.000 0.191 0.446

�c1R3

0.000 0.171 0.490 0.000 0.185 0.572

�c2R3

0.000 0.172 0.447 0.000 0.177 0.428

and therefore they do not need to depend heavily on the use ofmachine and system attributes to be effective. The performanceon the test set shows that the evolved R3 rules also have goodgeneralization qualities like that of the R2 rules. Mutation doesnot affect the GP system with R3 as strongly as the GP systemwith R1. The significant difference is only observed betweenthe experiment with no mutation and the experiment with themutation rate of 10% (p-value < 0.0031). Although thereis no obvious difference in the performance of evolved rulesfrom different configurations on the training set, R2 rules andR3 rules evolved with nonzero mutation rate are significantlybetter than R1 rules on the test set (all p-values < 0.0361over (3 + 2) × 3 = 15 statistical tests). Also, the evolved R3

rules from the GP system with nonzero mutation rates aresignificantly better than R1 and R2 rules on the test set (allp-values < 0.014 over 2 × (3 + 3) = 12 statistical tests).

Table V shows the performance of the evolved rules withfour selected existing dispatching rules for Jm||Cmax. Thevalues in this table are the statistics of relative deviations using(1) obtained when applying the evolved rules to the instancesin the training set and test set. The values of Mean can becalculated by using (2) to measure the average while min andmax values show the best-case and worst-case performanceof a dispatching rule on a given set of instances. From eachrepresentation, two evolved rules that show the best fitness inthe training stage are used here for comparison. Rule �

yvRx

isthe vth best rule that was evolved by using the representationRx to minimize objective function y for the JSP. For example,�c2

R2is the second best rule evolved with the representation R2

and Cmax as the objective function (t will be used to indicatethe total weighted tardiness).

Each simple dispatching rule is used to generate both activeand nondelay schedules for all instances in the training set andtest set. The results show that LRM with nondelay schedulingstrategy is better than other simple rules. The performance ofthe evolved rules are better than all of the simple dispatchingrules on the training set and test set. However, not all evolvedrules can produce consistent results when dealing with unseeninstances. Rules �c2

R1and �c2

R3are the rules that provide the

best performance on the test set even though they are not thebest rules on the training set. Generally, it seems quite difficultto develop a rule that produces good average and worst-caseperformance. One explanation is that the rules evolved withdevaverage(�) focus on the overall performance, therefore theymay ignore some extreme cases. Evolved rule �c2

R3is one

specific case when the best average performance and very goodworst-case performance is achieved.

B. Total Weighted Tardiness

In Table V-A, the experiments with R3 as the representationcan produce rules with better fitness than experiments withR1 or R2 as the representation. The statistical tests show thatevolved R3 rules from the GP system with nonzero mutationrates are significantly better than other evolved R1 and R2

rules on both training set and test set (all p-values < 0.0009over 2 × (3 + 3) × 2 = 24 statistical tests). These results againconfirm the effectiveness of the R3 representation. Also, theR1 rules from the GP system with nonzero mutation ratesare significantly better than R2 rules in this case (all p-values< 2×10−16 over 2×3×2 = 12 statistical tests). This suggeststhat the machine attributes and scheduling strategies are quiteimportant when dealing with Jm|| ∑wjTj .


TABLE VI

Performance of Evolved Rules for Jm||∑wjTj on Training Set and Test Set With Different Settings (mean ± standard deviation)

SettingR1 R2 R3

Training Testing Training Testing Training Testing〈95, 0, 5〉 −0.227 ± 0.004 −0.221 ± 0.005 −0.216 ± 0.003 −0.203 ± 0.005 −0.240 ± 0.015 −0.233 ± 0.015

devaverage(�) 〈90, 5, 5〉 −0.235 ± 0.006 −0.223 ± 0.003 −0.216 ± 0.004 −0.205 ± 0.006 −0.245 ± 0.012 −0.233 ± 0.014〈85, 10, 5〉 −0.237 ± 0.006 −0.222 ± 0.003 −0.216 ± 0.004 −0.204 ± 0.006 −0.247 ± 0.013 −0.235 ± 0.013

Negative values mean the evolved rules are better than EDD.

TABLE VII

Relative Deviations Obtained by Evolved Rules and Other Rules for Jm||∑wjTj

RulesTraining Set Test Set

Min Mean Max Min Mean Max

FIFOActive −0.318 0.455 1.600 −0.159 0.442 1.196

Nondelay −0.318 0.455 1.600 −0.159 0.442 1.196

LRMActive 0.193 0.832 2.129 −0.125 0.836 1.813

Nondelay −0.189 0.507 1.571 −0.236 0.494 1.425

MSActive 0.106 0.601 1.519 0.035 0.607 1.321

Nondelay −0.040 0.387 1.205 −0.133 0.363 0.822

WSPTActive −0.133 0.148 0.874 −0.154 0.160 0.946

Nondelay −0.394 −0.169 0.168 −0.459 −0.161 0.253

W(CR+SPT)Active −0.133 0.140 0.670 −0.234 0.147 0.858

Nondelay −0.398 −0.173 0.177 −0.459 −0.165 0.435

W(S/RPT+SPT)Active −0.110 0.149 0.867 −0.154 0.161 0.853

Nondelay −0.394 −0.168 0.168 −0.459 −0.161 0.253

COVERTActive −0.171 0.146 0.722 −0.235 0.147 0.853

Nondelay −0.394 −0.173 0.177 −0.459 −0.160 0.253

ATCActive −0.258 0.145 0.757 −0.260 0.140 0.795

Nondelay −0.394 −0.168 0.168 −0.459 −0.163 0.253

�t1R1

−0.586 −0.247 0.020 −0.560 −0.220 0.150

�t2R1

−0.531 −0.244 0.003 −0.507 −0.224 0.018

Evolved�t1

R2−0.467 −0.223 −0.003 −0.517 −0.199 0.326

�t2R2

−0.529 −0.223 0.151 −0.523 −0.206 0.116

�t1R3

−0.506 −0.265 −0.033 −0.616 −0.246 −0.002

�t2R3

−0.581 −0.265 −0.022 −0.555 −0.253 0.031

The comparison of the evolved rules and other dispatchingrules are shown in Table VII. It is easy to see that non duedate related rules such as FIFO and LRM have very poorperformance when dealing with Jm|| ∑wjTj even thoughLRM achieves good performance on Jm||Cmax. MS and WSPTshow better performance than FIFO and LRM because in-formation about the due date and the weight of a job isconsidered in these rules. While MS is still much worse thanEDD, WSPT shows good performance even though it stillcannot totally beat EDD. Sophisticated due-date related rulesW(CR+SPT), W(S/RPT+SPT), COVERT and ATC (see [47],[57] for a detailed description of these rules) which have notbeen included in the list of candidate dispatching rules arealso presented here. The expected waiting time in COVERTand ATC is calculated based on the standard method [47] inwhich the expected waiting time W = b×PR, where PR is theoperation processing time. For each method, two parametersneeded to be specified which are k (look-ahead parameter)and b. 25 combinations of b ∈ {0.5, 1.0, 1.5, 2.0, 2.5} andk ∈ {1.5, 2.0, 2.5, 3.0, 3.5} are examined on the training set,and the combination that gives the best average performanceis selected for comparison in the paper (k = 2.5, b = 2.5 forCOVERT and k = 1.5, b = 0.5 for ATC). The performance

of these rules is quite good since they are customized to dealwith weighted tardiness problems. However, in the worst case,they still cannot provide better schedules than those obtainedby EDD.

The best two evolved rules obtained by the GP system withdifferent settings are now compared with these human-madedispatching rules. On both the training set and the test set,all evolved rules show better average performance than theexisting rules. Similar to what has already been stated forJm||Cmax, R1 and R3 rules here are also much better thanR2 rules. However, it is still not easy to find a rule that totallydominates EDD. Among all the evolved rules, the evolvedR3 rules are the most promising ones. The best two evolvedR3 rules obtained very good average relative deviations forboth training set and test set compared to those obtained byR1 and R2 rules. Rule �t1

R3is also the only evolved adaptive

dispatching rule that totally dominates EDD on all trainingand testing instances. Meanwhile, �t2

R3produces a very good

average performance, even better than �t1R3

on the test set and itis just slightly worse than �t1

R3in the worst case. The promising

results of R3 rules again confirm the need for integratingmachine and system attributes with sophisticated dispatchingrules to produce generalized and effective dispatching rules.


VI. Analysis and Discussion

The previous section shows the results obtained by the pro-posed GP system and it is noted that the evolved rules can ef-fectively provide good results for Jm||Cmax and Jm|| ∑wjTj .In this section, we will further investigate the evolved rules tofigure out how they can produce good performance. An anal-ysis on the components of the evolved rules is given in orderto gain more understanding of each factor within the proposedrepresentations that may influence the ability of the GP systemto generate better rules. A comparison between the evolvedrules and some meta-heuristic approaches is then provided.Finally, the dispatching rules evolved by the proposed GPsystem are tested under a simulated dynamic JSP environment.

A. Insights from the Evolved Rules

In the previous experiment, there are 540 rules evolved withdifferent GP parameters and representations for Jm||Cmax andJm|| ∑wjTj . The performance of the two best evolved rulesfor each representation and each objective function of JSPwere shown in Tables V and VII. As an example, we pickone evolved rule from each representation among these rulesbased on their overall performance on the training set andtest set for further analysis (other evolved rules have a similarpattern).

1) Evolved Rules for Jm||Cmax: Here, �c1R1

, �c1R2

and �c2R3

are chosen for analysis. The detailed representations of theserules are shown in Fig. 7. For �c1

R1, the first observation is that

even though the rule looks complicated, it is just a combinationof four simple dispatching rules (LRM, SPT, LPT, and WSPT)and three machine attributes (CMI, CWR, DJ). Since WSPT isless relevant to Jm||Cmax and LPT is not very effective in thiscase, they only appear once in the entire adaptive dispatchingrule. The root condition of �c1

R1checks the critical machine

idleness and it is noted that LRM is the main dispatchingrule when the idleness of the critical machine is greater than10%. When CMI is small, the rule is more complicated andrules that favor small processing time operations like SPTand WSPT occur more in this case. This rule suggests thatwhen the critical machine is idle, the considered machineshould focus on completing operations with small processingtimes in order to feed more work to the critical machineand keep it busy; otherwise LRM should be used to preventcertain jobs from being completed so late and increase themakespan.

Different from �c1R1

, �c1R2

Fig. 7(b) is a pure mathematicalfunction. In order to make it easy for analysis, we will simplifythe whole function by eliminating terms which appear to beless relevant. The simplification step is as follows:

�c1aR2

= (PR+RM)WPR

− (RJ+RM)PR

RT+ RT

+ DD(PR+RM)RT W

(PR2) + RTPR

(RJ + RM)

≈ RT + RTPR

DD(PR+RM)

W(PR) + RT

PR(RJ + RM)

≈ RT + k × RTPR

.

Since the first and second terms of �c1R2

do not makemuch sense in this case, we just drop them from the priority

Fig. 7. Selected evolved rules for Jm||Cmax. (a) Evolved rule �c1R1

.(b) Evolved rule �c1

R2. (c) Evolved rule �c2

R3.

function.2 The rest of the function can be grouped in twoparts. The first part has RT , like rule MWKR, and the secondpart contains RT

PR, which is a combination of SPT and MWKR.

When considering other terms in the second part as a constantk, we have the approximation of �c1

R2as a linear combination

of MWKR and SPT/MWKR. This rule is actually not new. Ifwe omit RT in the approximation function, the rest is knownas shortest processing time by total work (SPTtwk) rule in theliterature.

Rule �c2R3

[see Fig. 7(c)] is the most interesting rule in thiscase because both arithmetic rules and simple dispatching rulesare employed. However, with the condition that MP has to beless than 100% at the second level, we can totally eliminatethe subtrees that contain the simple dispatching rules. Aftersome simplification steps, it is also noted that the arithmeticrules are also variants of SPTtwk. With the support of themachine attribute, the obtained arithmetic rules become mucheasier to analyse. The simplified version of �c2

R3is as follows:

�c2aR3

=

{〈 (RJ+0.594845)(RT+PR)W+PR

, α = 0.069〉, if CWR > 90%

〈 (RT−PR)(W+PR) , α = 0.128〉, otherwise

≈{〈 (RJ+0.594845)(RT+PR)

PR, α = 0.069〉, if CWR > 90%

〈 (RT−PR)PR

, α = 0.128〉, otherwise.

2The revised rules after dropping these irrelevant terms have been testedand it is noted that the performance is not significantly changed.


Fig. 8. Selected evolved rules for Jm||∑wjTj . (a) Evolved rule �t1R1

.(b) Evolved rule �t2

R2. (c) Evolved rule �t1

R3.

The notation 〈·, ·〉 indicates the dispatching rule and α valueas in the middle and right subtrees of Fig. 5. Although bothpriority functions of �c2

R3are variants of SPTtwk, the nondelay

factor α is smaller for the case when CWR > 90%. Oneexplanation is that when �′ contains many critical operations,it is reasonable to start the available operations right awayinstead of waiting for the operations that will be ready afterthe ready time of m∗.

2) Evolved Rules for Jm|| ∑wjTj: Here, �t1R1

, �t2R2

,and �t1

R3are selected to represent the evolved rules for

Jm|| ∑wjTj . The three full rules obtained by the GP areshown in Fig. 8. For �t1

R1, it is quite interesting that this rule

can obtain such a good result (as shown in Table VII) withoutany due-date related components. The two main simple dis-patching rules used in this case are WSPT and LPT. WhileWSPT can be considered as a suitable rule for Jm|| ∑wjTj ,it does not make sense to include LPT in this case. The resultwhen we replace LPT by WSPT shows that the refined rulecan still produce the results as good as �t1

R1. For this reason,

the contribution for the success of the rule comes from WSPTand other factors instead of the combination of different rulesas we observed in the previous section. It is noted that mostvalues of α in this case are about 0.4. Using these values forthe WSPT alone show that WSPT with appropriate choice ofα can produce the results much better than the case whenthe nondelay scheduling strategy is used. In this rule, thecontribution of the machine and system attributes are not veryimportant and they are mainly employed to improve the worst-case performance.

For �t2R2

, we perform the following steps to simplify theevolved rule:

�t2aR2

= 0.614PR2(−RM − RM

W) − RT × PR × RT

W

−(RTPR

W− 0.521) − 0.614

RM

WPR + 2RT

PR

(W − 0.5214191)

RM

W

≈ −0.614RM × PR2(1 +1

W) − RT

PR

W(RT + 2

RM

(W − 0.5214191))

≈ −k1 × PR2(1 +1

W) − k2 × RT

PR

W.

The simplified rule is a linear combination of two sophis-ticated variants of WSPT where the first part includes PR2

instead of PR and the second part includes RT . Repeating theexperiment on this simplified rule shows that it can performbetter than sophisticated rules like ATC and COVERT regard-ing the average relative deviation with appropriate choice ofk1 and k2 (with k2 > k1, similar to the original rule).

It is very surprising that the best evolved rule forJm|| ∑wjTj with the R3 representation is also the smallestrule. Rule �t1

R3can be formally described as follows:

�t1aR3

=

{〈−DD×PRW

, α = 0.331〉, if DJ ≤ 50%〈−DD×RT

W2 , α = 0.163〉, otherwise.

The dispatching rule following the first priority function is acombination of EDD and WSPT and it is applied when thedeviation of processing times of operations in �′ is less than50%, which means that the minimum processing time is lessthan half of the maximum processing time. When DJ is largerthan 50%, which means that the gap between the minimumand maximum processing time is small, RT is used instead ofPR and W2 is used instead of W to increase the priority ofjobs with small remaining processing times and high weights.

In general, even though the evolved rules can be very com-plicated sometimes, they always contain some good patternswhich are very useful for creating good dispatching schedules.While R1 rules can be easily explained with the support of themachine and system attributes, R2 rules are quite sophisticatedand often possess very interesting properties. It is surprisingthat the R3 rules presented here are quite straightforwardalthough they contain both machine attributes and compositedispatching rules. Rule �t1

R3could be quite tricky to represent

as a pure mathematical function and it could be more difficultto discover its useful patterns; however, the use of machineand system attributes makes it much easier to identify andexplain the rule.

B. Aggregate View of the Evolved Rules

Fig. 9 shows the frequency that machine and system at-tributes have occurred in all of the evolved R1 and R3 rules.For Jm||Cmax, critical machine related attributes are the mostfrequent ones while the bottleneck workload ratio has the low-est frequency. This result indicates that the information relatedto the critical machine is very important for the constructionof a good dispatching rule to minimize the makespan. Asshown in the previous section, suitable dispatching rules can beselected based on the idleness of the critical machine as wellas the critical workload of m∗. In the case of Jm|| ∑wjTj ,the critical machine related attributes are still employed very


TABLE VIII

Comparison of Evolved Rules With Meta-Heuristic Methods forJm||∑wjTj (h = 1.3)

instance optimal �t1R1

�t2R2

�t1R3

ATCα COVERTα GA-1 GA-2 LSRW(15) LSRW(200)

la16 1170 2000(a) 2521 2477 2360 2360 1623 1619 ∗ ∗la17 900 1623(c) 2107 1555(ac) 1936 1777 1464 1779 977 ∗la18 929 1764 1662 1325(a) 1439 1694 1248 1248 946 ∗la19 948 1884 2284 1505(bc) 1439(ab) 2189 1696 1671 966 951

la20 809 2702 2898 1784(a) 1866 2069 1402 1402 819 ∗la21’ 464 1280(c) 2293 1047(ac) 1530 1530 1044 1286 ∗ ∗la22’ 1068 1931 2270 2600 2960 1870(a) 1550 1909 1149 1086

la23’ 837 2053(a) 2100 2131 2605 2605 1094 1094 875 875

la24’ 835 1948 2692 1136(abc) 1875 1819 1403 1479 844 ∗orb01 2568 5247 5680 4210(ac) 6289 4583 4005 4865 2726 2616

orb02 1412 2526 2461(a) 2797 3022 2908 2143 2075 1434 1434

orb03 2113 4276 3968 2880(ac) 4215 4215 2866 4647 2289 2204

orb04 1623 3285 3060 2280(abc) 3945 3945 2326 3188 1816 1674

orb05 1593 3360 4031 1986(abc) 3511 3573 2533 2673 1802 1662

orb06 1792 3759 4098 3371(c) 3146(a) 3146(a) 3047 3689 1852 1802

orb07 590 1169 834(abc) 922(bc) 1324 1239 927 982 619 618

orb08 2429 2554(abcd) 5147 4570 3777(bc) 4404 3792 4103 2717 2554

orb09 1316 2388(abc) 2949 2415(c) 2679 3190 2061 2628 1449 1334

orb010 1679 3075 3186 2802(ac) 3418 3109 2217 2913 1837 1775

“GA-1” and “GA-2” represent GA-(R&M/COVERT) and GA-(R&R) [20]; ATCα and COVERTα showed the results from ATC and COVERT with α = 0.4.“*” means the method found the optimal solution; “a” means that it is the best rule among the three evolved rules for the instance;‘b” means that the evolved rule is better than GA-(R&M/COVERT) for the instance; “c” means that the evolved rule is better than GA-(R&R) for theinstance;“d” means that the evolved rule is better than LSRW(15) for the instance; and “e” means that the evolved rule is better than LSRW(200) for the instance

often, and CWR along with DJ are the ones with the highestoccurrence frequency. However, the distribution of attributesin Jm|| ∑wjTj are more uniform than that in Jm||Cmax. Thisobservation suggests that different attributes should be used toconstruct good dispatching rules for Jm|| ∑wjTj .

For the priority functions for composite dispatching ruleswithin R2 and R3 rules, Fig. 10 shows that RT and PR are themost used terms for Jm||Cmax. This explains the occurrence ofSPTtwk variants in the best rules in the previous section. WhileW is the least used term for Jm||Cmax, it is the most used termin Jm|| ∑wjTj . This emphasizes the importance of weightsfor determining the priority of operations in Jm|| ∑wjTj . It isquite surprising that the second most frequent term in evolvedrules for Jm|| ∑wjTj is PR instead of DD. Even though due-dates of jobs also depends on the processing times in aggregateform, the results here suggest that such local information asPR is still very useful for the dispatching tasks for due daterelated problems.

C. Comparison with Meta-Heuristic Methods

This section compares the performance of the evolved dis-patching rules to some improvement heuristics. Even thoughit seems unfair to the proposed GP method, since most meta-heuristic methods were especially developed for the staticenvironment and iteratively explore the solution search spaceof each instance for better solutions, the comparison canprovide an indicator about what kind of performance theevolved dispatching rules can achieve. In this section, we onlycompare the evolved rules with meta-heuristic methods forJm|| ∑wjTj because it is still a very challenging problemand total weighted tardiness is one of the most important andpractical objective functions in the scheduling literature.

Fig. 9. Frequency of attributes in the evolved R1 and R3 rules. (a) Jm||Cmax.(b) Jm||∑wjTj .

Table VIII shows the total weighted tardiness obtainedby the three best evolved rules for the three representationsmentioned above and dispatching rules ATC and COVERTwith fine-tuned α, and those obtained by the hybrid geneticalgorithm [20] and the large step random walk [19] onselected problem instances from [20] and [19]. In the table,GA-(R&M/COVERT) and GA-(R&R) are the two versionsof hybrid GA proposed by [20] (with population size of100 and 2000 generations) while LSRW(t) is the large stepoptimization method with running time equal to t seconds.The instances with bold names are ones that have been usedin the training set. Instance la21’ to la24’ are subproblemsof instance la21-la24 where the last five jobs were omittedhere. In Table VIII, rule �t1

R3produced the best performance

in most instances compared to other evolved rules. Although�t1

R3is a very simple rule, it is still able to beat the hybrid GAs

in several cases. Among 19 instances, �t1R3

outperforms GA-


Fig. 10. Frequency of terminals in the evolved R2 and R3 priority function.(a) Jm||Cmax. (b) Jm||∑wjTj .

(R&M/COVERT) in five cases and GA-(R&R) in 12 cases,including ones that have not been included in the training set.Although the objective values obtained by the hybrid GAsare still far from the optimal solutions and those found byLSRW, they are still very promising because they can bedirectly applied to the real dynamic system without majorredesign [20]. The hybrid GAs are also shown to dominatethe GA approach [58]. The fact that the GP evolved rulesin this paper can beat the hybrid GAs in some cases and becompetitive in other cases shows the effectiveness of theserules. Also, while the hybrid GAs need 200 000 evaluationsand LSRW requires about more than 15 seconds to solvean instance, the GP evolved rules can solve the whole setof 210 instances in less than one second. This suggests newrules can produce better performance and still maintain theefficiency of a dispatching rule. This characteristic makes theGP approach particularly useful for real-time applications.Another advantage of the proposed GP method is that it isable to automatically incorporate information and constraintsof different job shop environments into the rules; this it is avery hard task for conventional optimization methods.

D. Performance of Evolved Rules in a Dynamic JSP Environ-ment

This section examines the performance of the evolvedrules in a dynamic environment. A simulation model of asimple job shop environment is built for the evaluation ofthe evolved rules. Table IX shows the parameters of thesimulation model. With this configuration, the utilization ofeach machine λ

μis equal to the arrival rate λ (since μ = 1).

The due-date assignment rule is the same as that used in theprevious section. Each simulation experiment consists of 30replications and the common random seeds are used for eachexperiment in order to reduce the variance of the obtainedresults. The interval from the beginning of the simulation untilthe arrival of job 50 000 is considered as the warm-up timeand all statistics are collected for the next 100 000 jobs. Theresults obtained from the experiments are shown in Fig. 11.Since the JSP instances in the data set do not consider therelease times of jobs (all release times of jobs are assumedto be zero in all instances) which are very important for thedynamic Jm||Cmax, the evolved rules for Jm||Cmax are notsuitable for these experiments. So, only the evolved rules for

TABLE IX

Parameter Setting of the Simulation Model

Parameter ValueNumber of machines 6Arrival process Possion with λ from 0.5 to 0.9

Processing time Exponential with mean 1μ

= 1

Number of operations per job 6Visiting order of jobs Randomly generated with no machine

being revisitedWeight Randomly sampled from {4, 2, 1} with the

probabilities {0.2, 0.6, 0.2}

Fig. 11. Performance of the evolved rules in the dynamic environment(FIFOand EDD curves are above all other curves).

Jm|| ∑wjTj presented in Fig. 8 are investigated here. Forease of presentation, the total weighted tardiness is normalizedusing the formula proposed by [47]. Thus, the normalizedweighted tardiness =

∑wjTj

N×M× 1μ×w̄

, where the number of jobs

N = 100000, the number of machines M = 6, the averageprocessing time of an operation 1

μ= 1 and average weight of

a job w̄ = 2.2.In Fig. 11, the performance of the evolved rules are quite

consistent with what has been shown when dealing with thestatic problem. The results show that simple rules such as FIFOand EDD are easily dominated by the sophisticated rules likeATC, WSPT, COVERT and the evolved rules. When usingpairwise z-tests to compared the performance of these rules, itis noted that rule �t1

R1and rule �t1

R3are significantly better (p-

value � 0.05) than existing rules ATC, COVERT and WSPTwhen the utilization is less than or equal to 0.8, but they arebeaten by the existing rules when utilization is 0.9. On theother hand, the R2 rule is significantly worse than the existingrules for all levels of utilizations. The R2 rule is significantlyworse than R1 and R3 rules when the utilization is less thanor equal to 0.8 and better than R1 when utilization is 0.9. Oneof the reasons for the inferiority of the evolved rules whenthe utilization of the shop is high is that the evolved rules aretrained on a set of static instances which usually reflect thesituations in the dynamic job shop with a low utilization.

The investigation of the evolved rules in the dynamicenvironment shows that there is still a difference in thecharacteristics between the static problem and the dynamicproblem which sometimes prevent the evolved rules from


being effective in the dynamic environment. Although theevolved rules show good results in the dynamic Jm|| ∑wjTj ,the fact that they are inferior to the existing rules suggests thelack of generality of the data set used to train the dispatchingrules. The deteriorated performance of the evolved rules whenutilizations of machines are high is not because the GPsystem is not able to evolve effective rules but because thestatic training instances cannot represent all possible scenarioshappening in a dynamic environment. Thus, if the ultimateobjective of the dispatching rules is to be applied to thedynamic environment, it seems reasonable to train the rulesin the dynamic situation (e.g. via a simulation model) in orderto ensure that the evolved rules can capture all critical featuresof the dynamic system.

E. Further Discussions

Many analyses have been performed and it has been notedthat the GP system proposed in this paper can find effec-tive dispatching rules for the JSP. Different from traditionalapplications of evolutionary computation and meta-heuristicmethods which can only find a particular solution for aproblem instance, the GP system can evolve reusable rulesto solve different problem instances without the need to rerunthe search algorithm. Since a dispatching rule only providesone schedule for a static problem instance, it is very difficultfor these rules to outperform meta-heuristic methods whichperform improving steps by exploring thousands of schedulesto find better schedules. However, the fact that the evolvedrules can beat GA-(R&R) in many instances shows that it ispossible to generate powerful dispatching rules for the JSPthat are competitive with meta-heuristic methods. It is notedthat the program trees are restricted to the maximum depthof six in this paper and many other machine attributes aswell as terminals (scheduling parameters) are not consideredwhen the GP system is used to evolve new dispatching rules.These restrictions are made to reduce the computational timesof the GP system but they also prevent the GP system fromfinding better dispatching rules. If a better choice of functionset, terminal set, and machine attributes is made, it maybe possible that the GP system can evolve rules that areas good as effective meta-heuristic methods but much moreefficient.

One major advantage of the evolved rules is that they arequite ready to be applied to the dynamic environment as shownin the previous subsection, which makes these rules morepractical than meta-heuristic methods. Therefore the evolvedrules are suitable for shops with rapid dynamic changes[22], [59], [60]. In these shops, even when mathematicalprogramming methods are able to find optimal schedules, theseschedules can quickly become suboptimal or even infeasibleunder dynamic conditions [22]. Besides, with its flexibility, theproposed GP system can easily be applied to generate goodrules for complex manufacturing processes (e.g. batch process-ing, assembly station, etc.), which are difficult to be handled byconventional optimization methods. Another advantage of theevolved dispatching rules is that they are understandable to theusers (managers, operators, and researchers), and therefore itis much easier for these people to incorporate these rules with

other planning decisions compared to the detailed schedulesproduced by other methods.

Most of the proposed GP systems [5], [8], [39], [40] in theliterature is very similar to ours when the R2 representationis used. Miyashita [8] and Jakobovic and Budin [6] arethe only works that focus on the use of system attributes,specifically bottleneck machines, to support the sequencingdecisions. However, it is noted that the GP system proposedby Miyashita [8] is only suitable when we try to evolvedispatching rules for a specific shop with a small numberof machines in which the bottleneck machine is known.Therefore, it is difficult to generalise the rules based on on thisGP system. Jakobovic and Budin [6] improved this GP system[8] by using a dedicated GP tree to detect the bottleneckmachine to apply suitable dispatching rules. The problem isthat the bottleneck machine is not always a good featureto help decide which dispatching rules to be applied. Whenthere are multiple bottleneck machines in the shop, especiallywith a symmetrical shop, applying a dedicated rule for thedetected bottleneck is not very effective since the temporarybottleneck machine can change rapidly before that rule showsany noticeable effect. This explains why the proposed GP-3system [6] performs significantly better than the simple GPsystem, but the gaps between the objectives obtained by GP-3and the simple GP are not large. When examining the GP-3 system with our training and testing instances, using thesame terminal sets for dispatching rules in R2 and R3, theexperimental results show that there is no significant differencebetween the rules evolved by GP-3 and rules evolved with theR2 representation. The analysis in Section VI-B also showedthat the workload ratio WR, an indicator for the bottlenecklevel of the considered machine, is not a major attribute in thebest evolved rules. This suggests that different machine andsystem attributes should be used instead of depend solely onbottleneck machines.

Compared to the existing methods, the novelties of thispaper are: 1) the introduction of new representations (R1 andR3) that allow the GP system to evolve effective adaptive dis-patching rules by incorporating machine and system attributes;2) the comparison of different representations for GP; and (3)the analysis of the evolved dispatching rules, which explainhow they solve JSP instances effectively.

VII. Conclusion

Dispatching rules are one of the most crucial tools inproduction planning and control systems and a large numberof studies were conducted to develop more effective rules.However, the development process is still very complicatedand time consuming. The improvement in computing powerprovides some alternatives to facilitate this process. In thispaper, we investigated the use of genetic programming asa hyper-heuristic method for automatically discovering newdispatching rules for the job shop scheduling problem. Newrepresentations of dispatching rules that take advantage ofthe machine and system attributes to support the sequencingdecisions were developed and examined. The experimentalresults suggested that the GP system can evolve effective


dispatching rules for Jm||Cmax and Jm|| ∑wjTj with therepresentations that integrate system attributes and suitablecomposite dispatching rules. The evolved rules were alsoshown to outperform the existing rules on the training set andtest set. Moreover, the best evolved rules produced competitiveperformances when compared to the hybrid GAs of [20].Although the performance of the evolved rules was still farfrom the optimal solutions in the static JSP, they are stillvery promising because they are quite ready to be appliedto a dynamic system whereas the solutions provided by theexact and meta-heuristic methods have trouble dealing withthe dynamics of the shop change. The simulation experimentshave confirmed the effectiveness of the evolved rules comparedto well-known dispatching rules in the dynamic environment.Also, compared to the solutions obtained by the conventionalmeta-heuristic approaches, the evolved rules in this paper pro-vided much better interpretability of the sequencing decisions.Another advantage of the proposed GP system is that it onlyrequires one run to generate dispatching rules which can beused to solve multiple problem instances.

In general, this is the first paper that has compared differentrepresentations of dispatching rules used in a GP system andinvestigated how representations influence the performanceof the GP system when evolving dispatching rules for theJSP. With their flexibility, the proposed representations in thispaper can be easily extended to deal with different manufac-turing environments. Moreover, these representations providea convenient way to incorporate special system features ofreal world environments into the adaptive dispatching rules.Therefore, the GP system proposed in this paper can also beemployed as a good tool to automatically discover effectivedispatching rules for a particular manufacturing system. Theanalysis in the previous section has shown very interestingcharacteristics of the evolved rules.

For future studies, there are still many problems that needto be further investigated. This paper has shown that theexplicit incorporation of machine and system attributes intothe decision making process can provide favorable results.Therefore, it would be very useful to have a comprehensivestudy of potential attributes and their effects on each type ofmanufacturing environment. Also, since the dispatching ruleswill be applied to dynamic situations, whether it is necessaryto evolve these rules in the dynamic environment throughsome simulation model would be an important question forthe future research. In addition, while the technique of dis-patching rules can quickly react to changes encountered onthe shop floor, some cognitive and organizational practicalissues [59] need to be considered. It would be interesting tostudy these issues when designing the dispatching rules, suchas by developing a multiobjective GP-HH method to evolverules that can satisfy multiple practical requirements. Fitnesslandscapes defined by different fitness functions would be veryinteresting to explore and will be a good topic for futureresearch. Finally, even though the proposed representation isuseful, it also creates a large search space for the GP system toexplore. For that reason, it would be worthwhile paying moreattention to the design of specialized genetic operators to beable to find the good rules.

References

[1] S. S. Panwalkar and W. Iskander, “A survey of scheduling rules,” Oper.Res., vol. 25, no. 1, pp. 45–61, 1977.

[2] M. S. Jayamohan and C. Rajendran, “Development and analysis of cost-based dispatching rules for job shop scheduling,” Eur. J. Oper. Res., vol.157, no. 2, pp. 307–321, 2004.

[3] M. S. Jayamohan and C. Rajendran, “New dispatching rules for shopscheduling: A step forward,” Int. J. Prod. Research, vol. 38, no. 3, pp.563–586, 2000.

[4] L. Nie, X. Shao, L. Gao, and W. Li, “Evolving scheduling rules withgene expression programming for dynamic single-machine schedulingproblems,” Int. J. Adv. Manufacturing Technol., vol. 50, no. 5, pp. 729–747, 2010.

[5] J. C. Tay and N. B. Ho, “Evolving dispatching rules using geneticprogramming for solving multiobjective flexible job-shop problems,”Comput. Industrial Eng., vol. 54, no. 3, pp. 453–473, 2008.

[6] D. Jakobovic and L. Budin, “Dynamic scheduling with genetic program-ming,” in Proc. EuroGP, 2006, pp. 73–84.

[7] T. Hildebrandt, J. Heger, and B. Scholz-Reiter, “Toward improved dis-patching rules for complex shop floor scenarios: A genetic programmingapproach,” in Proc. GECCO, 2010, pp. 257–264.

[8] K. Miyashita, “Job-shop scheduling with GP,” in Proc. GECC, 2000,pp. 505–512.

[9] S. Nguyen, M. Zhang, M. Johnston, and K. C. Tan, “A coevolutiongenetic programming method to evolve scheduling policies for dynamicmultiobjective job shop scheduling problems,” in Proc. IEEE Congr.CEC, Jun. 2012, pp. 3261–3268.

[10] S. Nguyen, M. Zhang, M. Johnston, and K. C. Tan, “Evolvingreusable operation-based due-date assignment models for job shopscheduling with genetic programming,” in Proc. 15th EuroGP, 2012,pp. 121–133.

[11] X. Li and S. Olafsson, “Discovering dispatching rules using datamining,” J. Scheduling, vol. 8, no. 6, pp. 515–527, 2005.

[12] H. Ingimundardottir and T. Runarsson, “Supervised learning linearpriority dispatch rules for job-shop scheduling,” in Proc. LION 5, 2011,pp. 263–277.

[13] B. Giffler and G. L. Thompson, “Algorithms for solving production-scheduling problems,” Oper. Res., vol. 8, no. 4, pp. 487–503,1960.

[14] A. Jones, L. C. Rabelo, and A. T. Sharawi, “Survey of job shop schedul-ing techniques,” in Wiley Encyclopedia of Electrical and ElectronicsEngineering. New York: Wiley, 2001.

[15] H. R. Lourenco, “Job-shop scheduling: Computational study of localsearch and large-step optimization methods,” Eur. J. Oper. Res., vol. 83,no. 2, pp. 347–364, 1995.

[16] E. Nowicki and C. Smutnicki, “A fast taboo search algorithm forthe job shop problem,” Manage. Sci., vol. 42, no. 6, pp. 797–813,1996.

[17] E. Balas and A. Vazacopoulos, “Guided local search with shiftingbottleneck for job shop scheduling,” Manage. Sci., vol. 44, no. 2, pp.262–275, 1998.

[18] R. Cheng, M. Gen, and Y. Tsujimura, “A tutorial survey of job-shopscheduling problems using genetic algorithms, Part II: Hybrid geneticsearch strategies,” Comput. Industrial Eng., vol. 36, no. 2, pp. 343–364,1999.

[19] S. Kreipl, “A large step random walk for minimizing total weightedtardiness in a job shop,” J. Scheduling, vol. 3, no. 3, pp. 125–138,2000.

[20] H. Zhou, W. Cheung, and L. C. Leung, “Minimizing weighted tardinessof job-shop scheduling using a hybrid genetic algorithm,” Eur. J. Oper.Res., vol. 194, no. 3, pp. 637–649, 2009.

[21] K. N. McKay, F. R. Safayeni, and J. A. Buzacott, “Job-shop schedul-ing theory: What is relevant?” Interfaces, vol. 18, no. 4, pp. 84–90,1988.

[22] S. C. Sarin, A. Varadarajan, and L. Wang, “A survey of dispatching rulesfor operational control in wafer fabrication,” Prod. Planning Control,vol. 22, no. 1, pp. 4–24, 2011.

[23] E. K. Burke, M. R. Hyde, G. Kendall, G. Ochoa, E. Ozcan, andJ. R. Woodward, “A classification of hyper-heuristic approaches,” inHandbook of Metaheuristics (Int. Series in Operations Research andManagement Science, vol. 146). Berlin, Germany: Springer, 2010, pp.449–468.

[24] E. K. Burke, M. R. Hyde, G. Kendall, G. Ochoa, E. Ozcan, and R. Qu,“Hyper-heuristics: A survey of the state of the art,” School of ComputerScience and Inform. Technol., Univ. Nottingham, Computer ScienceTechnical Report No. NOTTCS-TR-SUB-0906241418-2747, 2010.


[25] E. K. Burke, M. R. Hyde, G. Kendall, G. Ochoa, E. Ozcan, andJ. R. Woodward, “Exploring hyper-heuristic methodologies with geneticprogramming,” in Computational Intelligence (Series Intelligent SystemsReference Library), vol. 1, C. Mumford and L. Jain, Eds., Berlin,Heidelberg: Springer, 2009, pp. 177–201.

[26] A. Bolte and U. W. Thonemann, “Optimizing simulated annealingschedules with genetic programming,” Eur. J. Oper. Res., vol. 92, no. 2,pp. 402–416, 1996.

[27] A. Fukunaga, “Automated discovery of composite SAT variable-selection heuristics,” in Proc. 18th Nat. Conf. Artificial Intell., 2002,pp. 641–648.

[28] M. B. Bader-El-Den and R. Poli, “Generating SAT local-search heuris-tics using a GP hyper-heuristic framework,” in Proc. 8th Int. Conf.Artificial Evol., 2007, pp. 37–49.

[29] E. K. Burke, M. R. Hyde, and G. Kendall, “Evolving bin pack-ing heuristics with genetic programming,” in Proc. PPSN, 2006, pp.860–869.

[30] E. K. Burke, M. R. Hyde, G. Kendall, and J. R. Woodward, “Thescalability of evolved online bin packing heuristics,” in Proc. IEEE CEC,Sep. 2007, pp. 2530–2537.

[31] E. K. Burke, M. R. Hyde, G. Kendall, and J. R. Woodward, “A geneticprogramming hyper-heuristic approach for evolving two dimensionalstrip packing heuristics,” IEEE Trans. Evolu. Comput., vol. 14, no. 6,pp. 942–958, Dec. 2010.

[32] R. Keller and R. Poli, “Linear genetic programming of parsimoniousmetaheuristics,” in Proc. IEEE CEC, Sep. 2007, pp. 4508–4515.

[33] R. Keller and R. Poli, “Cost-benefit investigation of a genetic-programming hyperheuristic,” in Proc. 8th Int. Conf. Artifcial Evolu.,2007, pp. 13–24.

[34] M. B. Bader-El-Den, R. Poli, and S. Fatima, “Evolving timetablingheuristics using a grammar-based genetic programming hyper-heuristicframework,” Memetic Computing, vol. 1, no. 3, pp. 205–219, 2009.

[35] E. K. Burke, M. R. Hyde, and G. Kendall, “Grammatical evolution oflocal search heuristics,” IEEE Trans. Evolu. Comput., vol. 16, no. 3, pp.406–417, Jun. 2012.

[36] C. Dimopoulos and A. M. S. Zalzala, “Investigating the use of geneticprogramming for a classic one-machine scheduling problem,” Adv. Eng.Software, vol. 32, no. 6, pp. 489–498, 2001.

[37] D. Jakobovic, L. Jelenkovic, and L. Budin, “Genetic programmingheuristics for multiple machine scheduling,” in Proc. EuroGP, 2007,pp. 321–330.

[38] C. D. Geiger, R. Uzsoy, and H. Aytug, “Rapid modeling and discoveryof priority dispatching rules: An autonomous learning approach,” J.Heuristics, vol. 9, no. 1, pp. 7–34, 2006.

[39] C. D. Geiger and R. Uzsoy, “Learning effective dispatching rules forbatch processor scheduling,” Int. J. Prod. Res., vol. 46, no. 6, pp. 1431–1454, 2008.

[40] W. J. Yin, M. Liu, and C. Wu, “Learning single-machine schedulingheuristics subject to machine breakdowns with genetic programming,”in Proc. IEEE CEC, Dec. 2003, pp. 1050–1055.

[41] L. Atlan, J. Bonnet, and M. Naillon, “Learning distributed reactivestrategies by genetic programming for the general job shop prob-lem,” in Proc. 7th Annu. Florida Artificial Intell. Res. Symp., 1994,p. 11.

[42] C. Pickardt, J. Branke, T. Hildebrandt, J. Heger, and B. Scholz-Reiter,“Generating dispatching rules for semiconductor manufacturing to min-imize weighted tardiness,” in Proc. WSC, 2010, pp. 2504–2515.

[43] J. A. Vazquez-Rodriguez and G. Ochoa, “On the automatic discovery ofvariants of the NEH procedure for flow shop scheduling using geneticprogramming,” J. Oper. Res. Soc., vol. 62, no. 2, pp. 381–396, 2011.

[44] D. J. John, “Co-evolution with the Bierwirth–Mattfeld hybrid scheduler,”in Proc. 9th Annu. Conf. GECCO, 2002, p. 259.

[45] S. Petrovic and E. Castro, “A genetic algorithm for radiotherapypre-treatment scheduling,” in Proc. Appl. Evolu. Comput., 2011, pp.454–463.

[46] W. J. Hopp and M. L. Spearman, Factory Physics: Foundations ofManufacturing Management. New York: McGraw-Hill, 2000.

[47] A. P. J. Vepsalainen and T. E. Morton, “Priority rules for job shopswith weighted tardiness costs,” Manage. Science, vol. 33, no. 8, pp.1035–1047, 1987.

[48] J. R. Koza, Genetic Programming: On the Programming of Computersby Means of Natural Selection. Cambridge, MA: MIT Press, 1992.

[49] P. Pardalos and O. Shylo, “An algorithm for the job shop schedulingproblem based on global equilibrium search techniques,” Comput. Man-age. Sci., vol. 3, no. 4, pp. 331–348, 2006.

[50] S. Luke. (2009). Essentials of Metaheuristics[Online]. Available:http://cs.gmu.edu/∼sean/book/metaheuristics/

[51] S. Lawrence, “Resource constrained project scheduling: An experimentalinvestigation of heuristic scheduling techniques,” Ph.D. dissertation,Graduate School Ind. Adm., Carnegie-Mellon Univ., Pittsburgh, PA,1984.

[52] D. Applegate and W. Cook, “A computational study of the job-shopscheduling instance,” ORSA J. Computing, vol. 3, no. 2, pp. 149–156,1991.

[53] E. Taillard, “Benchmarks for basic scheduling problems,” Eur. J. Oper.Res., vol. 64, no. 2, pp. 278–285, 1993.

[54] E. Demirkol, S. Mehta, and R. Uzsoy, “Benchmarks for shop schedul-ing problems,” Eur. J. Oper. Res., vol. 109, no. 1, pp. 137–141,1998.

[55] K. R. Baker, “Sequencing rules and due-date assignments in a job shop,”Manag. Sci., vol. 30, no. 9, pp. 1093–1104, 1984.

[56] M. Pinedo and M. Singer, “A shifting bottleneck heuristic for minimizingthe total weighted tardiness in a job shop,” Naval Res. Logistics, vol. 46,no. 1, pp. 1–17, 1999.

[57] P. Mizrak and G. M. Bayhan, “Comparative study of dispatching rulesin a real-life job shop environment,” Appl. Artificial Intell., vol. 20, no.7, pp. 585–607, 2006.

[58] D. C. Mattfeld and C. Bierwirth, “An efficient genetic algorithm for jobshop scheduling with tardiness objectives,” Eur. J. Oper. Res., vol. 155,no. 3, pp. 616–630, 2004.

[59] J. Riezebos, J. M. Hoc, N. Mebarki, C. Dimopoulos, W. Wezel, andG. Pinot, “Design of scheduling algorithms: Applications,” in BehavioralOperations in Planning and Scheduling, J. C. Fransoo, T. Waefler, andJ. R. Wilson, Eds., Berlin: Springer, 2011, pp. 371–412.

[60] T. Sloan, “Shop-floor scheduling of semiconductor wafer fabs: Exploringthe influence of technology, market, and performance objectives,” IEEETrans. Semiconductor Manufacturing, vol. 16, no. 2, pp. 281–289, May2003.

Su Nguyen received the B.E. degree in industrialand systems engineering from the Ho Chi MinhCity University of Technology, Hochiminh City,Vietnam, in 2006, and the M.E. degree in indus-trial engineering and management from the AsianInstitute of Technology (AIT), Bangkok, Thailand.He is currently pursuing the Ph.D. degree with theEvolutionary Computation Research Group, VictoriaUniversity of Wellington (VUW), Wellington, NewZealand.

Prior to VUW, he was a Research Associate ofindustrial and manufacturing engineering with the School of Engineeringand Technology, AIT. His current research interests include evolutionarycomputation, discrete-event simulation, and their applications in operationsplanning and scheduling.

Mengjie Zhang (SM’10) received the B.E. and M.E.degrees from the Artificial Intelligence ResearchCenter, Agricultural University of Hebei, Baoding,China, in 1989 and 1992, respectively, and the Ph.D.degree in computer science from RMIT University,Melbourne, Australia, in 2000.

Since 2000, he has been with the Victoria Univer-sity of Wellington, Wellington, New Zealand. He iscurrently a Professor of computer science and headsthe Evolutionary Computation Research Group. Hiscurrent research interests include evolutionary com-

putation, genetic programming, and particle swarm optimization with ap-plication areas of image analysis, multiobjective optimization, classificationwith unbalanced data, and feature selection and dimension reduction forclassification with high dimensions.

Dr. Zhang is a member of the IEEE Computer Society, the IEEE CI Society,and the IEEE SMC Society. He is also a member of the IEEE CIS EvolutionaryComputation Technical Committee, a member of the IEEE CIS IntelligentSystems Applications Technical Committee, a Vice Chair of the IEEE CISTask Force on Evolutionary Computer Vision and Image Processing, anda Committee Member of the IEEE New Zealand Central Section. He is amember of the ACM and the ACM SIGEVO Group. He has been serving asan Associate Editor or Editorial Board Member for five international journals.


Mark Johnston (M’10) received the B.Sc. degreein mathematics and computer science and the Ph.D.degree in operations research from Massey Univer-sity, Palmerston North, New Zealand.

He is currently a Senior Lecturer with the VictoriaUniversity of Wellington, Wellington, New Zealand,where he teaches various operation research courses.His current research interests include primarily com-binatorial optimization and evolutionary computa-tion, with a particular interest in scheduling models,genetic programming, and multiple-objective opti-

mization.

Kay Chen Tan (SM’08) received the B.Eng. degree(First Class Honors) in electronics and electrical en-gineering and the Ph.D. degree from the Universityof Glasgow, Glasgow, Scotland, U.K., in 1994 and1997, respectively.

He is currently an Associate Professor with theDepartment of Electrical and Computer Engineering,National University of Singapore, Singapore. He haspublished over 100 journal papers, over 100 papersin conference proceedings, co-authored five books,and co-edited four books.

He served as the General Co-Chair for the IEEE Congress on EvolutionaryComputation, Singapore, in 2007, and the General Co-Chair for the IEEESymposium on Computational Intelligence in Scheduling, Tennessee, in 2009.He has been an IEEE Distinguished Lecturer of the IEEE ComputationalIntelligence Society since 2011. He is currently the Editor-in-Chief of theIEEE Computational Intelligence Magazine. He also serves as anAssociate Editor and Editorial Board member of over 15 international journals.He was a recipient of the 2012 IEEE Computational Intelligence SocietyOutstanding Early Career Award. He was a recipient of the RecognitionAward in 2008 from the International Network for Engineering Educationand Research (iNEER). He was a recipient of the NUS Outstanding EducatorAward in 2004, the Engineering Educator Award in 2002, 2003, and 2005,the Annual Teaching Excellence Award in 2002, 2003, 2004, 2005, and 2006,and the Honor Roll Award in 2007.

Documents

A Computational Study of Representations in Genetic Programming to Evolve Dispatching Rules for the Job Shop Scheduling Problem