# A Hybrid Genetic Algorithm to Minimize Total Tardiness for Unrelated Parallel Machine Scheduling with Precedence Constraints

Authors: Chunfeng Liu
Journal: Mathematical Problems in Engineering
 (2013)

---

## Abstract

The paper presents a novel hybrid genetic algorithm (HGA) for a deterministic scheduling problem
where multiple jobs with arbitrary precedence constraints are processed on multiple unrelated
parallel machines. The objective is to minimize total tardiness, since delays of the jobs may lead
to punishment cost or cancellation of orders by the clients in many situations. A priority rule-based
heuristic algorithm, which schedules a prior job on a prior machine according to the priority
rule at each iteration, is suggested and embedded to the HGA for initial feasible schedules that
can be improved in further stages. Computational experiments are conducted to show that the
proposed HGA performs well with respect to accuracy and efficiency of solution for small-sized
problems and gets better results than the conventional genetic algorithm within the same runtime
for large-sized problems.


---

## Body

## 1. Introduction

We consider an unrelated parallel machine scheduling problem with arbitrary precedence constraints to minimize total tardiness. Such a problem typically occurs in an office or project management environment, where unrelated machines represent workers who have different skills in office scheduling problem, or represent various types of resources which are allocated to activities in multimode project scheduling problem. Moreover, a task (or project) can be separated into several subtasks (or activities) with precedence constraints between them (e.g., one subtask may have to be finished before another subtask can be started). In many situations, delays of the subtasks (or activities) may lead to punishment cost or cancellation of orders by the clients. Mangers should adopt some methods to select the suitable workers (or resources) to undertake each subtask (or activity) separately, in order to maximize utilization of these workers (or resources), improve productivity, and reduce overall cost.The remainder is organized as follows. A comprehensive review of the related literature is presented in Section2. The problem is formulated as an integer programming model in Section 3. In Section 4, a priority rule-based heuristic algorithm (PRHA) is suggested for the feasible schedules. In Section 5, a hybrid genetic algorithm (HGA), taking the solutions of the PRHA as a part of initial population, is proposed for the final solution. In Section 6, two categories of numerical experiments are conducted to evaluate the performance of the proposed HGA. Finally, the paper closes with a general discussion of the proposed approach as well as a few remarks on research perspectives in Section 7.


## 2. The Literature Review

There are some studies about multiplemachines and precedence constraints in the literature. The machines may be identical, that is, they have equal speeds, or uniform, that is, each machine has a constant speed, independent of the tasks, or they may be unrelated if the speed of each machine depends on the task it processes. Precedence constraints include chains, out-tree, in-tree, forest, special precedence constraints, and arbitrary precedence constraints.For identical machine scheduling with precedence-related jobs, Ramachandra and Elmaghraby [1] offered a binary integer program (BIP) and a dynamic program (DP) to solve two-machine problem with arbitrary precedence constraints to minimize total weighted completion time. They have also introduced a genetic algorithm (GA) procedure that is capable of solving any problem size. Queyranne and Schulz [2] presented a 4-approximation algorithm for the identical machine problem with precedence delays to minimize total weighted completion time. In that problem each precedence constraint is associated with a certain amount of time that must elapse between the completion and start times of the corresponding jobs. Kim et al. [3] considered an identical machine problem with s-precedence constraints to minimize total completion time and formulated it as an LP problem with preemption allowed. To solve the LP problem efficiently, they developed a cutting plane approach in which a pseudopolynomial dynamic programming algorithm was derived to solve the involved separation problem. Gacias et al. [4] proposed an exact branch-and-bound procedure and a climbing discrepancy search (CDS) heuristic for the identical machine scheduling problem with precedence constraints and setup times between the jobs. Driessel and Mönch [5] suggested several variants of variable neighborhood search (VNS) schemes for scheduling jobs on identical machines with sequence-dependent setup times, precedence constraints, and ready times. Yuan et al. [6] considered the online scheduling on two identical machines with chain precedence constraints to minimize makespan, where jobs arrive over time and have identical processing times,and provided a best possible online algorithm of competitive ratio (13-1)/2.For uniform machine scheduling with precedence-related jobs, Brucker et al. [7] considered a problem of scheduling identical jobs with chain precedence constraints on two uniform machines. It was shown that the corresponding makespan problem could be solved in linear time. Woeginger [8] proposed a 2-approximation algorithm for uniform machine problem subject to chain precedence constraints to minimize makespan. Kim [9] derived an LP-based heuristic procedure for scheduling s-precedence constrained jobs on uniform machines with different speeds to minimize the weighted total completion time. van Zuylen [10] proved a randomized O(logm)-approximation algorithm that is monotone in expectation for scheduling uniform machines with precedence constraints to minimize makespan.For unrelated machine scheduling with precedence-related jobs, Herrmann et al. [11] considered chain precedence constraints between the tasks and proposed a number of heuristics to minimize makespan. Kumar et al. [12] presented polylogarithmic approximations to minimize makespan and total weighted completion time when the precedence constraints forming a forest. Nouri and Ghodsi [13] studied a scheduling problem where some related tasks with exponential duration were processed by some unrelated workers so that the total expected time to execute the tasks is minimum and gave a polynomial time algorithm for the problem in the restricted form.In addition, for unrelated machine scheduling with tardiness related criteria, Chen and Chen [14] considered a flexible flow line scheduling problem with unrelated parallel machines at each stage and with a bottleneck stage on the line and proposed the bottleneck-based heuristics to minimize total tardiness. Zhang et al. [15] addressed a dynamic unrelated machine scheduling problem where the arrival time and the due date of each job are stochastic and applied a reinforcement learning method to minimize mean weighted tardiness. Liaw et al. [16] examined an unrelated machine scheduling problem to minimize the total weighted tardiness and presented a branch-and-bound algorithm incorporating various dominance rules. Kim et al. [17] presented an unrelated machine scheduling problem with sequence dependent setup times and suggested four search heuristics to minimize total weighted tardiness: the earliest weighted due date, the shortest weighted processing time, the two-level batch scheduling heuristic, and the simulated annealing method.To the best of our knowledge, there is no work on unrelated machine scheduling problem with total tardiness criteria and precedence constraints of the jobs. Motivated from that fact, a hybrid genetic algorithm (HGA) is proposed for the practical scheduling problem.


## 3. Problem Formulation

A setJ={1,…,n} of n jobs has to be processed on m unrelated parallel machines M={1,…,m}. Each machine is capable of processing these jobs at different speeds and can process at most one job at a time. Each job is ready at the beginning of the scheduling horizon, processed on only one machine, and nonpreemptive during the processing period. Each job j has an integer processing time pjv on machine v and a distinct due date dj. There are arbitrary precedence constraints between the jobs. The constraints force a job not to be started before all its predecessors are finished. The objective is to find a feasible schedule that minimizes total tardiness tt=∑j=1n‍max(FTj-dj,0), where tardiness of job j is the amount of time its finish time FTj exceeds its due date dj. In standard scheduling notation [18], this problem can be denoted as Rm|prec|tt, where R denotes unrelated parallel machines, and prec denotes arbitrary precedence constraints. The problem is NP-hard even for a single machine [19].The problem can be represented as a mathematical formulation as follows:(1)minimizett=∑j=1n‍max(FTj-dj,0)(2)subjectto∑v=1m‍∑r=1ϕ‍xjvr=1,∀j∈J,(3)∑j=1n‍xjvr⩽1,∀r∈R,∀v∈M,(4)∑i=1n‍xivr-∑j=1n‍xj,v,r-1⩽0,∀v∈M,∀r∈{2,…,ϕ},(5)FTj-FTi+L(2-xjvr-xi,v,r-1)⩾pjv,∀i,j∈J,i≠j,∀v∈M,∀r∈{2,…,ϕ},(6)FTj⩾∑r=1ϕ‍pjvxjvr,∀j∈J,∀v∈M,(7)FTj-FTi⩾∑v=1m‍∑r=1ϕ‍pjvxjvr,∀i∈Pj,(8)xjvr∈{0,1},FTj⩾0,∀j∈J,∀v∈M,∀r∈R.The input parameters of the model includeJ:
the job set,J={1,…,n};M:
the machine set,M={1,…,m};ϕ:
the maximum number of positions on each machine that jobs are placed on them. It is computed as follows:ϕ=n-m+1 (i.e., the maximum machine utilization is met, so that all machines are used);R:
the position set,R={1,…,ϕ};pjv:
the processing time of jobj on machine v;dj:
the due date of taskj,j∈J;Pj:
the set of immediate predecessors of jobj;L:
a large positive number.The decision variables of the model includexjvr:
equals 1 if jobj is processed in the position r on machine v and 0 otherwise;FTj:
the finish time of jobj.The objective function (1) minimizes the total tardiness. Constraints (2) ensure that each job is assigned to one of the existing positions on the machines. Constraints (3) guarantee that at most one job can be assigned to each position. Constraints (4) ensure that until one position on a machine is occupied, jobs are not assigned to subsequent positions. Constraints (5) ensure that the finish time of a job in sequence on a machine is at least equal to the sum of the finish time of the preceding job and the processing time of the present job. Constraints (6) ensure that the finish time of each job is not less than its processing time. Constraints (7) observe precedence relationships. Constraints (8) define the type of decision variables.


## 4. Priority Rule-Based Heuristic Algorithm

Heuristics have taken an important position in the research of solutions in many combinatory problems, as it is simple, easy to implement, and can be embedded in more sophisticated heuristics or metaheuristics for determining initial feasible schedules that can be improved in further stages. We develop a priority rule-based heuristic algorithm (PRHA) consisting of several iterations. At each iteration, a prior job is selected according to EDD (earliest due date first) rule and inserted inside a partial schedule on a selected prior machine (respecting the precedence constraints), while keeping the start times of the already scheduled jobs unchanged. The prior machine can be selected according to different conditions.Then, three job-sets associated with each iteration are defined. Jobs which have been finished up to the schedule time point are in the completion job-setCu. Jobs which have been scheduled are in the total scheduled job-set H. Jobs which are available for scheduling with respect to precedence constraints but yet unscheduled are in the decision job-set Du.The variables used for the PRHA are summarized as follows:u:
the counter of iteration;H:
the total scheduled job-set;Cu:
the completion job-set at theuth iteration;Du:
the decision job-set at theuth iteration, Du={j∣j∉H,Pj⊆Cu};Iv:
the release time of machinev (i.e., the machine is not occupied after the time point);(j*,v*):
the prior job-machine pair (j* and v* indicate the selected prior job and prior machine, resp.);Fjv:
the hypothetical finish time of jobj when processed on machine v;t:
the scheduling time point.We give a pseudocode description of the priority rule-based heuristic algorithm which consists ofn iterations (cf. Algorithm 1). Step 1 initializes some variables u, H, tt, and Iv. In step 2 each job is scheduled at each iteration until u⩽n does not hold. In step 2.1 T is denoted as a set containing the release times of all machines. In step 2.2 the scheduling time point t is determined by the minimum release time of machines. The completion job-set Cu and the decision job-set Du at the time point t are computed in steps 2.3 and 2.4. In step 2.5 the schedule time point t is postponed to the next minimum release time until Du is not empty. In step 2.6 an EDD rule is used to determine a prior job that is, the job with minimum due date in Du is selected as the prior job j*. Each hypothetical finish time Fj*v of job j* on machine v of the set M is first computed in step 2.7, and then the prior machine v* is selected in step 2.8. If all hypothetical finish times of job j* are not less than its due date, the machine with minimum hypothetical finish time is selected as the prior machine v*; otherwise, v* is randomly selected from these machines which process job j* with the associated hypothetical finish times less than its due date. In step 2.9 the start and finish times of job j* and the release time of machine v* are saved. The total scheduled job-set H, total tardiness tt, and counter of iteration u are updated in steps 2.10–2.12.Algorithm 1:Priority rule-based heuristic algorithm.
1. Initialize:u=1, H=∅, tt=0;
Iv=0,∀v∈M
2.WHILE (u⩽n) DO
2.1.T={Iv∣v∈M}
2.2.t=min{τ∣τ∈T}
2.3.Cu={j∣FTj⩽t,∀j∈H}
2.4. computeDu
2.5.WHILE (Du=∅) DO
2.5.1.T:=T∖{t}
2.5.2.t=min{τ∣τ∈T}
2.5.3.Cu={j∣FTj⩽t,∀j∈H}
2.5.4. computeDu
2.6.j*:dj*=min{dj∣j∈Du}
2.7.FOR (v=1:m)
IF (Iv⩾t)
Fj*v=Iv+pj*v
ELSE
Fj*v=t+pj*v
2.8.IF (Fj*v⩾dj*,∀v∈M)
v*:Fj*v*=min{Fj*v∣v∈M}
ELSE
randomly select v* from {v∣Fj*v<dj*,v∈M}
2.9.STj*=Fj*v*-pj*v*,FTj*=Fj*v*,Iv*=FTj*
2.10.H:=H∪{j*}
2.11.tt:=tt+max(FTj*-dj*,0)
2.12.u:=u+1To better illustrate the proposed PRHA, let us consider a simple instance. Nine jobs have to be processed on two unrelated parallel machines. The processing times and due dates of all jobs are given in Table1, and the precedence constraints are displayed in Figure 1. The solution is reached after nine iterations using the PRHA. Table 2 shows the computational process of each iteration.Table 1
Problem data of the instance.
job1
job2
job3
job4
job5
job6
job7
job8
job9
p
j
1
3
4
8
2
5
9
3
5
8
p
j
2
9
5
2
6
9
4
8
7
5
d
j
3
4
5
7
9
8
11
13
12Table 2
Summary of iterations.
u
D
u
j
*
v
*
S
T
j
*
F
T
j
*
tt
1
{
1,2
,
3
}
1
1
0
3
0
2
{
2,3
}
2
2
0
5
1
3
{
3
}
3
2
5
7
3
4
{
4,5
,
6
}
4
1
7
9
5
5
{
5,6
}
6
2
7
11
8
6
{
5,7
}
5
1
9
14
13
7
{
7,9
}
7
1
14
17
19
8
{
9
}
9
2
11
16
23
9
{
8
}
8
1
17
22
32Figure 1
Project precedence constraints graph of the instance.Whenu=1, the decision job-set Du is computed in step 2.5. The selected prior job j*=1 is processed on the selected prior machine v*=1, started at time STj*=0, and completed at time FTj*=3, which are calculated in steps 2.6, 2.8, and 2.9. The total tardiness tt=0 is computed in step 2.11. The following iterations are similar to the first iteration. The final solution is presented by the Gantt chart in Figure 2.Figure 2
Gantt chart using the PRHA.


## 5. Proposed HGA and Its Implementation

Genetic algorithm (GA) is a powerful and broadly applicable stochastic search and optimization technique based on principles of evolution theory. In the past few years, GA has received considerable attention for solving difficult combinatorial optimization problems.We propose a hybrid genetic algorithm (HGA) which combines the PRHA approach with conventional genetic algorithm. In HGA, the PRHA plays an important role in generating good initial solutions to avoid the blind search of GA at the beginning while exploring the solution space. The HGA explores the solution spaces with three genetic operators, including the patching crossover, swap mutation, and “roulette wheel” selection. The principle of HGA is illustrated in Figure3, and the detailed description is as follows.Figure 3
Program flow chart of the HGA.


### 5.1. Coding and Fitness Function

The first step in the proposed HGA is to consider a chromosome representation or solution structure. Suppose that there aren jobs to be assigned to m machines. A chromosome is modeled by a string of n+m-1 distinct genes, composed of n job genes, numbered from 1 to n, and m-1 partitioning genes “*” with distinct subscripts to separate the machines [20]. Meanwhile, the chromosome may be decomposed as m subchromosomes, and genes of each subchromosome represent unordered jobs on a machine. An example is demonstrated in Figure 4, where the chromosome would assign jobs 9, 1, 5 to machine 1, jobs 8, 6, 2 to machine 2, job 7 to machine 3, and jobs 3, 4 to machine 4. When there are no job genes between two consecutive partitioning genes, the corresponding machine of the second partitioning gene is not occupied in the schedule. Similarly, when there are no job genes after the last partitioning gene, the rest machine is not occupied in the schedule.Figure 4
Chromosome encode.The HGA manipulates solutions to propagate similarities among the high performance chromosomes to the next population based on fitness values. The fitness function corresponds to the objective function under consideration. Since each job has a constant processing time in its subchromosome, the start and finish times of all jobs can be computed by applying a revised forward recursion algorithm (RFRA) according to the precedence constraints (cf. Algorithm2). The fitness value of each chromosome can thus be obtained.Algorithm 2:Revised forward recursion algorithm.
1. Initialize unscheduled job-setU={1,…,n} and the release times of all machines
I
v
=
0
,
∀
v
∈
M.
2. Repeat the following steps untilU is empty:
2.1. randomly select a jobj from U.
2.2. Assign jobj to machine k (k is known for job j according to the chromosome).
2.2.1. If the finish time of predecessori of job j is not known, execute step 2.2
for jobi recursively.
2.2.2. Letξj denote the maximum finish time of the predecessors of job j.
Compute the start time and finish time of jobj:
STj=max(ξj,Ik),FTj=STj+pjk.
2.2.3. Update the unscheduled job-set and the release time of machinek:
U:=U∖{j},Ik=FTj.
3.tt=∑j=1n‍max(FTj-dj,0).We use the instance in Section4 to illustrate the RFRA. Suppose that jobs 1, 2, 3, 5, 6, and 7 are assigned to machine 1 and jobs 4, 8, and 9 are assigned to machine 2. Figure 5 shows the computational process of the RFRA. At first, the job 1 is randomly selected from the unscheduled job-set U={1,2,3,4,5,6,7,8,9}, and the finish time FT1=3 is computed in step 2.2.2. Then, the job 6 is randomly selected from the set U={2,3,4,5,6,7,8,9}. Because the finish time of predecessor 3 of job 6 is not known yet, step 2.2 is executed for job 3 recursively, and the finish time FT3=11 can be calculated. The following iterations are similar to the previous iterations, and the final total tardiness is 157.Figure 5
The computational process of the RFRA.


### 5.2. Initial Population

PopSize is the population size or the number of chromosomes at each population that is known in advance. In the HGA, the population is initialized from two subpopulations with identical number of chromosomes: one subpopulation comes from the solutions of the PRHA, so that it can enhance population optimization; the other is generated by randomly assigning all jobs to the machines, so that it can enhance population diversity.


### 5.3. Crossover

Crossover is the kernel operation in genetic algorithm, which combines two chromosomes to generate next-generation chromosomes preserving their characteristics. In our crossover, all chromosomes in the parent generation are mutually crossed over according to a given crossover probabilityPc. The mechanism is accomplished through the following steps, and Figure 6 demonstrates an example.(i)
Choose two chromosomes, named Parent1 and Parent2, from the parent population.(ii)
Randomly produce a string ofn+m-1 flags, each with value of either “0” or “1”.(iii)
The flags are first matched with Parent1 such that those genes with flag “1” in Parent1 are selected and saved in Selected1 with their original positions unchanged.(iv)
Cross out the same genes as Selected1 from Parent2, and the remainder genes are saved in Selected2.(v)
The new offspring is obtained through filling out the remaining empty gene locations of Selected1 with the genes of Selected2 by preserving their gene sequence in Selected2.(vi)
The genes of offspring are assigned to the subchromosomes according to the subindexed “*”.(vii)
The fitness value of offspring is computed by applying the RFRA algorithm.Figure 6
Example of our crossover mechanism.An offspring acceptance method is employed to accept the offspring generated by crossover operator [21]. If the fitness value of offspring is not greater than the average fitness value of its parent generation, the offspring will be accepted for the new generation and will be thrown otherwise. This method reduces the computational time of the algorithm and leads to convergence toward the optimum solution neighborhood.


### 5.4. Mutation

Mutation reorganizes the structure of genes in a chromosome randomly so that a new combination of genes may appear in the next generation. It serves the search by jumping out of local optimal solutions. The swap mutation is used as mutation operator according to a given mutation probabilityPm, and all offsprings from the mutation are accepted for the new generation. The mechanism is accomplished through the following steps, and Figure 7 demonstrates an example.(i)
Randomly select two genes from two different subchromosomes in a selected chromosome and swap their places.(ii)
The genes of new offspring are assigned to the subchromosomes according to the subindexed “*”.(iii)
The fitness value of offspring is computed by applying the RFRA algorithm.Figure 7
Example of our mutation mechanism.


### 5.5. Selection

Selection is an operation to choose good chromosomes for the next generation. It is important in regulating the bias in the reproduction process. Letαgk denote the selection value of the kth chromosome in generation g before selection. It is computed as
(9)αgk=s+maxi∈{1,…,e}Fgi-Fgk,
where Fgk is the fitness value of the kth chromosome in generation g, e is the number of chromosomes in generation g before selection, and s is a small constant (say 3). Obviously, the less the fitness value of chromosome, the greater its selection value (i.e., the selection value and fitness value of the chromosome have an inverse relationship). Generally, it is better that the solution with minimum fitness value (i.e., maximum selection value) in the current generation has more chance to be selected as parent in order to create offspring. The most common method for the selection mechanism is the “roulette wheel" sampling. Each chromosome is assigned a slice of the circular roulette wheel and the size of the slice is proportional to the selection value of chromosome. The wheel is spun PopSize times. On each spin, the chromosome under the wheel’s marker is selected to be in the pool of parents for the next generation.


### 5.6. Stopping Rules

The HGA is stopped with satisfying either of the following conditions: (1) the number of current generation(g) is greater than the maximum number of generation (Gmax), and (2) the standard deviation of the fitness values of chromosomes in the current generation (σg) is not greater than an arbitrary constant (ε) [22]. σg implies a degree of diversity or similarity in the current population in terms of the fitness value. It is computed as
(10)σg=[(1PopSize)∑k=1PopSize‍(Fgk-F¯g)2]1/2,
where F¯g is the mean fitness value of all chromosomes in generation g that is computed as F¯g=(1/PopSize)∑k=1PopSize‍Fgk.


## 5.1. Coding and Fitness Function

The first step in the proposed HGA is to consider a chromosome representation or solution structure. Suppose that there aren jobs to be assigned to m machines. A chromosome is modeled by a string of n+m-1 distinct genes, composed of n job genes, numbered from 1 to n, and m-1 partitioning genes “*” with distinct subscripts to separate the machines [20]. Meanwhile, the chromosome may be decomposed as m subchromosomes, and genes of each subchromosome represent unordered jobs on a machine. An example is demonstrated in Figure 4, where the chromosome would assign jobs 9, 1, 5 to machine 1, jobs 8, 6, 2 to machine 2, job 7 to machine 3, and jobs 3, 4 to machine 4. When there are no job genes between two consecutive partitioning genes, the corresponding machine of the second partitioning gene is not occupied in the schedule. Similarly, when there are no job genes after the last partitioning gene, the rest machine is not occupied in the schedule.Figure 4
Chromosome encode.The HGA manipulates solutions to propagate similarities among the high performance chromosomes to the next population based on fitness values. The fitness function corresponds to the objective function under consideration. Since each job has a constant processing time in its subchromosome, the start and finish times of all jobs can be computed by applying a revised forward recursion algorithm (RFRA) according to the precedence constraints (cf. Algorithm2). The fitness value of each chromosome can thus be obtained.Algorithm 2:Revised forward recursion algorithm.
1. Initialize unscheduled job-setU={1,…,n} and the release times of all machines
I
v
=
0
,
∀
v
∈
M.
2. Repeat the following steps untilU is empty:
2.1. randomly select a jobj from U.
2.2. Assign jobj to machine k (k is known for job j according to the chromosome).
2.2.1. If the finish time of predecessori of job j is not known, execute step 2.2
for jobi recursively.
2.2.2. Letξj denote the maximum finish time of the predecessors of job j.
Compute the start time and finish time of jobj:
STj=max(ξj,Ik),FTj=STj+pjk.
2.2.3. Update the unscheduled job-set and the release time of machinek:
U:=U∖{j},Ik=FTj.
3.tt=∑j=1n‍max(FTj-dj,0).We use the instance in Section4 to illustrate the RFRA. Suppose that jobs 1, 2, 3, 5, 6, and 7 are assigned to machine 1 and jobs 4, 8, and 9 are assigned to machine 2. Figure 5 shows the computational process of the RFRA. At first, the job 1 is randomly selected from the unscheduled job-set U={1,2,3,4,5,6,7,8,9}, and the finish time FT1=3 is computed in step 2.2.2. Then, the job 6 is randomly selected from the set U={2,3,4,5,6,7,8,9}. Because the finish time of predecessor 3 of job 6 is not known yet, step 2.2 is executed for job 3 recursively, and the finish time FT3=11 can be calculated. The following iterations are similar to the previous iterations, and the final total tardiness is 157.Figure 5
The computational process of the RFRA.


## 5.2. Initial Population

PopSize is the population size or the number of chromosomes at each population that is known in advance. In the HGA, the population is initialized from two subpopulations with identical number of chromosomes: one subpopulation comes from the solutions of the PRHA, so that it can enhance population optimization; the other is generated by randomly assigning all jobs to the machines, so that it can enhance population diversity.


## 5.3. Crossover

Crossover is the kernel operation in genetic algorithm, which combines two chromosomes to generate next-generation chromosomes preserving their characteristics. In our crossover, all chromosomes in the parent generation are mutually crossed over according to a given crossover probabilityPc. The mechanism is accomplished through the following steps, and Figure 6 demonstrates an example.(i)
Choose two chromosomes, named Parent1 and Parent2, from the parent population.(ii)
Randomly produce a string ofn+m-1 flags, each with value of either “0” or “1”.(iii)
The flags are first matched with Parent1 such that those genes with flag “1” in Parent1 are selected and saved in Selected1 with their original positions unchanged.(iv)
Cross out the same genes as Selected1 from Parent2, and the remainder genes are saved in Selected2.(v)
The new offspring is obtained through filling out the remaining empty gene locations of Selected1 with the genes of Selected2 by preserving their gene sequence in Selected2.(vi)
The genes of offspring are assigned to the subchromosomes according to the subindexed “*”.(vii)
The fitness value of offspring is computed by applying the RFRA algorithm.Figure 6
Example of our crossover mechanism.An offspring acceptance method is employed to accept the offspring generated by crossover operator [21]. If the fitness value of offspring is not greater than the average fitness value of its parent generation, the offspring will be accepted for the new generation and will be thrown otherwise. This method reduces the computational time of the algorithm and leads to convergence toward the optimum solution neighborhood.


## 5.4. Mutation

Mutation reorganizes the structure of genes in a chromosome randomly so that a new combination of genes may appear in the next generation. It serves the search by jumping out of local optimal solutions. The swap mutation is used as mutation operator according to a given mutation probabilityPm, and all offsprings from the mutation are accepted for the new generation. The mechanism is accomplished through the following steps, and Figure 7 demonstrates an example.(i)
Randomly select two genes from two different subchromosomes in a selected chromosome and swap their places.(ii)
The genes of new offspring are assigned to the subchromosomes according to the subindexed “*”.(iii)
The fitness value of offspring is computed by applying the RFRA algorithm.Figure 7
Example of our mutation mechanism.


## 5.5. Selection

Selection is an operation to choose good chromosomes for the next generation. It is important in regulating the bias in the reproduction process. Letαgk denote the selection value of the kth chromosome in generation g before selection. It is computed as
(9)αgk=s+maxi∈{1,…,e}Fgi-Fgk,
where Fgk is the fitness value of the kth chromosome in generation g, e is the number of chromosomes in generation g before selection, and s is a small constant (say 3). Obviously, the less the fitness value of chromosome, the greater its selection value (i.e., the selection value and fitness value of the chromosome have an inverse relationship). Generally, it is better that the solution with minimum fitness value (i.e., maximum selection value) in the current generation has more chance to be selected as parent in order to create offspring. The most common method for the selection mechanism is the “roulette wheel" sampling. Each chromosome is assigned a slice of the circular roulette wheel and the size of the slice is proportional to the selection value of chromosome. The wheel is spun PopSize times. On each spin, the chromosome under the wheel’s marker is selected to be in the pool of parents for the next generation.


## 5.6. Stopping Rules

The HGA is stopped with satisfying either of the following conditions: (1) the number of current generation(g) is greater than the maximum number of generation (Gmax), and (2) the standard deviation of the fitness values of chromosomes in the current generation (σg) is not greater than an arbitrary constant (ε) [22]. σg implies a degree of diversity or similarity in the current population in terms of the fitness value. It is computed as
(10)σg=[(1PopSize)∑k=1PopSize‍(Fgk-F¯g)2]1/2,
where F¯g is the mean fitness value of all chromosomes in generation g that is computed as F¯g=(1/PopSize)∑k=1PopSize‍Fgk.


## 6. Computational Experiments

To evaluate the performance of the proposed HGA, the following two categories of numerical experiments for small and large-sized problems are conducted. The small-sized problems are solved by the branch-and-bound approach (B&B) under the CPLEX software and the proposed HGA. The large-sized problems are solved by the HGA and the conventional genetic algorithm (CGA) which is not combined with the priority rule-based heuristic algorithm, since they cannot be optimally solved by the CPLEX in a reasonable CPU time. Through referring to [23] and preliminary tests, the appropriate parameters of the HGA are determined and listed in Table 3. The CGA is stopped when its runtime reaches the HGA’s.Table 3
Parameters of the HGA.
Parameter
Value
Population size (PopSize)
20
Crossover probability(Pc)
0.9
Mutation probability(Pm)
0.05
Arbitrary constant for stopping criterion(ε)
0.0001
Maximum number of generation(Gmax)
200The processing times of the jobs are randomly generated inDU[a,b] which represents a discrete uniform distribution with a range from a to b. The due dates are randomly obtained by [24]
(11)di=[(θ2m)(1-ρ-RD2),(θ2m)(1-ρ+RD2)],(12)θ=∑j=1n‍∑v=1m‍pjv,
where ρ is the delay coefficient and RD is the relative range of due dates. To produce the precedence relations, let D = density of precedence constraints = Pr{arc(i,j) exists in precedence constraints}, and let Pij = Pr{arc(i,j) exists in the immediate precedence graph}, for 1⩽i<j⩽n, where i,j are different jobs and Pr is abbreviation of probability. Hall and Posner [25] have proved that
(13)Pij=D(1-D)j-i-11-D(1-(1-D)j-i-1).
For a given D, each precedence relation of jobs i and j can be determined by Pij.The experiments have been performed on a Pentium-based Dell-compatible personal computer with 2.30 GHz clock-pulse and 2.00 GB RAM. The HGA and CGA algorithms have been coded in C++, compiled with the Microsoft Visual C++ 6 compiler, and tested under Microsoft Windows 7 (64-bit) operating system.The first category of experiments is conducted for the small-sized problems. We generate nine groups of problem instances (each group including 10 instances), given the density of precedence constraintsD=0.5, the delay coefficient ρ=0.5, the relative range of due dates RD=0.1, and the processing times pjv~[1,10]. Each instance is solved by the HGA; meanwhile, its exact solution is achieved by the B&B under the CPLEX 12.2 software. Let fBB and fHGA denote the mean objective function values (i.e., total tardiness) of the problem group using the B&B and HGA, respectively, and let Gap denote the relative distance between fBB and fHGA; that is, Gap=(fHGA-fBB)/fBB×100%. The computational results are shown in Table 4. It can be observed that for the small-sized problems, the HGA is able to get good results (the average Gap is only 0.3%) and to obtain exact solutions (i.e., Gap=0) for most of the problems. In addition, it also can be seen from the average of mean CPU time of the B&B and HGA (24.5 s and 3.1 s) that the runtime of the B&B is not obviously comparable with the one of HGA. Figure 8 shows a typical convergence of the HGA during 27 successive generations related to a single run.Table 4
Performance of the HGA for small-sized instances.
No. of group
D
=
0.5 ρ=0.5 RD=0.1 pjv~[1,10]
B&B
HGA
n
m
f
BB
Mean CPU time (s)
f
HGA
Mean CPU time (s)
Gap (%)
1
9
4
39
1.5
39
0.4
0
2
9
3
72
5.5
72
0.6
0
3
9
2
61
72.7
61
0.7
0
4
10
4
68
9.3
68
7.1
0
5
10
3
63
2.9
63
5.7
0
6
10
2
64
18.7
65
8.4
1.6
7
11
4
32
86.2
32
2,3
0
8
11
3
123
2.8
124
0.6
0.8
9
11
2
129
20.5
129
1.9
0
Average
24.5
3.1
0.3Figure 8
A typical convergence of the HGA during 27 successive generations related to a single run.The second category of experiments is conducted for the large-sized problems. The performance of the HGA is compared with the CGA by use of six impact factors including number of jobs(n), number of machines (m), density of precedence constraints (D), delay coefficient (ρ), relative range of due dates (RD), and processing times (pjv). Here, six sets of subexperiments are conducted. In the first set displayed in Table 5, n is allowed to vary to test its impact effect, given m=10, D=0.6, ρ=0.5, RD=0.1, and pjv~DU[1,10]. The other five sets displayed in Tables 6–10 test the effects of varying m, D, ρ, RD, and pjv, respectively. Each table entry represents 10 randomly generated instances. Let fHGA and fCGA denote the mean objective function values using the HGA and CGA, respectively, and let ΔfGA denote the declining percentage of fHGA lower over fCGA, that is, ΔfGA=(fCGA-fHGA)/fCGA×100%.Table 5
Comparison between HGA and CGA for large-sized instances with different number of jobs(n).
m
=
10
f
HGA
f
CGA
Mean CPU time (s)
Δ
f
GA (%)
D
=
0.6
ρ
=
0.5
RD
=
0.1
p
j
v
~
DU
[
1,10
]
n
30
129.6
216.3
59.1
40.1
60
311.9
807.4
182.9
61.4
90
914.1
2882.5
360.8
68.3
120
855.5
5500.5
603.9
84.4Table 6
Comparison between HGA and CGA for large-sized instances with different number of machines(m).
n
=
60
f
HGA
f
CGA
Mean CPU time (s)
Δ
f
GA (%)
D
=
0.6
ρ
=
0.5
RD
=
0.1
p
j
v
~
DU
[
1,10
]
m
5
773.6
1252.2
163.6
38.2
10
316.0
794.7
184.2
60.2
15
204.2
717.2
205.9
71.5
20
281.8
698.7
228.7
59.7Table 7
Comparison between HGA and CGA for large-sized instances with different density of precedence constraints(D).
n
=
60
f
HGA
f
CGA
Mean CPU time (s)
Δ
f
GA (%)
m
=
10
ρ
=
0.5
RD
=
0.1
p
j
v
~
DU
[
1,10
]
D
0.2
100.8
364.0
183.2
72.3
0.4
135.5
481.1
182.8
71.8
0.6
375.5
935.6
183.2
59.9
0.8
782.0
1733.3
184.3
54.9Table 8
Comparison between HGA and CGA for large-sized instances with different delay coefficients(ρ).
n
=
30
f
HGA
f
CGA
Mean CPU time (s)
Δ
f
GA (%)
m
=
5
D
=
0.6
RD
=
0.1
p
j
v
~
DU
[
1,10
]
ρ
0.3
248.7
313.0
105.2
20.5
0.5
226.7
311.2
112.1
27.2
0.7
297.9
377
112.3
21.0
0.9
497.4
583.0
113.0
14.7Table 9
Comparison between HGA and CGA for large-sized instances with different relative range of due dates (RD).
n
=
30
f
HGA
f
CGA
Mean CPU time (s)
Δ
f
GA (%)
m
=
5
D
=
0.6
ρ
=
0.5
p
j
v
~
DU
[
1,10
]
RD
0.1
265.0
370.2
97.3
28.4
0.3
311.2
411.4
112.5
24.4
0.5
293.6
436.4
114.6
32.7
0.7
226.8
323.8
77.8
30.0Table 10
Comparison between HGA and CGA for large-sized instances with different processing times(pjv).
n
=
60
f
HGA
f
CGA
Mean CPU time (s)
Δ
f
GA (%)
m
=
10
D
=
0.6
ρ
=
0.5
RD
=
0.1
p
j
v
DU
[
1,5
]
263.1
531.1
183.7
50.5
DU
[
1,10
]
304.1
843.5
183.3
63.9
DU
[
1,15
]
290.2
1047.3
183.1
72.3
DU
[
1,20
]
598.8
1631.0
183.7
63.3From Tables5, 6, 7, 8, 9, and 10 we can see that, within the same runtime ΔfGA can reach 14.7%–84.4%, and it increases markedly as the number of jobs (n) increases. This also shows the optimization advantage of the HGA regardless of different number of machines, different density of precedence constraints, different delay coefficient, different relative range of due dates, and different processing times, because the HGA takes the solutions of heuristic algorithm as a part of initial population, which avoids blind search of the CGA. It is worth mentioning that the total tardiness will decrease generally as m increases; however, each instance is randomly generated under given conditions in Table 6, so fCGA may show an obvious down trend for the solutions using the CGA are not exact results, and fHGA may show an approximate down trend for the solutions using the HGA are very near to exact results. Table 10 shows the same situation for the reason of randomly generated instances. Moreover, ΔfGA decreases as the density of precedence constraints (D) increases in Table 7, because as D increases, the precedence relations of all jobs become tighter, the schedule of these jobs tends to be more deterministic, and the advantage of the HGA over CGA will decrease.


## 7. Conclusions

In this paper, an intuitive priority rule-based heuristic algorithm (PRHA) is first developed for the unrelated machine scheduling problem to construct some feasible schedules. The PRHA can schedule a prior job on a prior machine according to the priority rule at each iteration. Then, a hybrid genetic algorithm (HGA) is proposed to improve the final solution. We design subindexed genes, genetic operators, and add the standard deviation of the fitness values as stopping criterion to the traditional genetic algorithm. The fitness values can be computed through the revised forward recursion algorithm.In order to evaluate the effectiveness and efficiency of the proposed HGA, two categories of numerical experiments are conducted. The obtained results show that the HGA performs accurately and efficiently for small-sized problems and can obtain exact solutions for most cases. Moreover, it gets better results than the conventional genetic algorithm within the same runtime for large-sized problems. However, the advantage of the HGA over CGA will decrease if the due dates of all jobs are identical or large enough, because the selection method for the prior job and machine in the PRHA algorithm may be ineffective.The HGA can be applied to the just-in-time production systems considering penalties for tardy jobs. An important research direction that might be pursued in the future is extension of the developed priority rule in this work. The other potential interest would be to consider lower bound and exact algorithms for the complex problem.



---

*Source: 537127-2013-07-15.xml*