A knowledge-based evolutionary strategy for scheduling problems with bottlenecks

Discrete Optimization

A knowledge-based evolutionary strategy forscheduling problems with bottlenecks

Ramiro Varela a,*, Camino R. Vela a, Jorge Puente a, Alberto Gomez b

a Centro de Inteligencia Artificial, Departamento de Informatica, Universidad de Oviedo, Campus de Viesques-Geijon,

E-3327 1 Gij�oon, Spainb Dpto. de Administracion de Empresas y Contabilidad, Universidad de Oviedo. Campus deViesques. E-33271 Gij�oon, Spain

Received 29 November 1999; accepted 11 December 2001

Abstract

In this paper we confront a family of scheduling problems by means of genetic algorithms: the job shop scheduling

problem with bottlenecks. Our main contribution is a strategy to introduce specific knowledge into the initial popu-

lation. This strategy exploits a probabilistic-based heuristic method that was designed to guide a conventional back-

tracking search. We report experimental results on two benchmarks, the first one includes a set of small problems and is

taken from the literature. The second includes medium and large size problems and is proposed by our own. The

experimental results show that the performance of the genetic algorithm clearly augments when the initial population is

seeded with heuristic chromosomes, the improvement being more and more appreciable as long as the size of the

problem instance increases. Moreover premature convergence which sometimes appears when randomness is limited in

any way in a genetic algorithm is not observed.

� 2002 Elsevier Science B.V. All rights reserved.

Keywords: Genetic algorithms; Heuristics; Optimization; Scheduling theory; Job shop scheduling

1. Introduction

It is well known that scheduling problems are

a subclass of combinatorial problems that arise

everywhere. We can find problems of this class in

many areas of industry, management and science,

ranging from production organization to multi-processor scheduling. This fact not only justifies

the intensive research carried out in this field over

the recent years [5,12–15,19,21,23], but also the

interest in finding new solutions to specific families

of problems. Because scheduling problems are in

general NP-hard, the only practical approaches

are heuristic strategies some of the most common

being state space search, branch and bound, dis-patching rules, tabu search, simulated annealing

and genetic algorithms (GAs). In [4] and [11] we

can found an extensive study about the main

techniques that were applied over the last years.

The application of GAs to scheduling problems

European Journal of Operational Research 145 (2003) 57–71

www.elsevier.com/locate/dsw

*Corresponding author. Tel.: +34-8-5182032; fax: +34-8-

5182125.

E-mail addresses: [email protected] (R. Varela), camino@

aic.uniovi.es (C.R. Vela), [email protected] (J. Puente),

[email protected] (A. Gomez).

URL: http://www.aic.uniovi.es.

0377-2217/03/$ - see front matter � 2002 Elsevier Science B.V. All rights reserved.

PII: S0377-2217 (02 )00205-9

mail to: [email protected]

http://www.aic.uniovi.es

has interested many researchers [2,6,7,16,22,26]

due to the fact that they seem to offer the ability to

cope with the huge search spaces involved in op-

timizing schedules. Because conventional GAs

have proved to lay out results that are rather poor

for medium and large size problems, a number ofenhancements like elitism, local search and struc-

tured population technique, have been proposed

to improve their performance.

In this paper, we confront the job shop sched-

uling (JSS) problem by means of a GA and pro-

pose a strategy to generate an initial population

that allows us to introduce heuristic knowledge

from the problem domain into the initial chro-mosomes. In order to do that we exploit the

variable and value ordering heuristics proposed by

Sadeh [20]. These heuristics were defined to guide a

conventional backtracking search and perform

well when solving problems with bottleneck re-

sources, because they can identify these resources

and envisage suitable partial schedules to them. As

we will see, JSS with bottlenecks is an interestingfamily because many real problems belong to this

family. In order to validate our approach, we

made an experimental study on two benchmarks

of JSS problems with bottlenecks. First we con-

sider the set of 60 problems proposed in [20]. These

are small size problems, however as far as we know

this is the only benchmark of problems with bot-

tlenecks available to the community of researches.Hence we propose a new benchmark with medium

and large size problems with bottlenecks. We re-

port experimental results showing that a GA

whose initial population is seeded with heuristic

chromosomes outperforms the same GA using a

random initial population.

The remainder of the paper is organized as

follows. In Section 2 we introduce the JSS con-straint satisfaction problem and define the subclass

of JSS with bottleneck resources. Section 3 de-

scribes the GA used in this study, in particular the

codification of chromosomes and genetic opera-

tors. It also discusses two possibilities to build the

schedule that a given chromosome represents and

how to define the fitness function. Section 4 re-

views the variable and value ordering heuristicsproposed by Sadeh. Section 5 describes the way we

propose to generate the initial population from the

probabilistic knowledge provided by these heuris-

tics. Section 6 reports the experimental results;

here we consider results regarding the efficiency

and convergence of various versions of the GA.

Finally, in Section 7, we present the main conclu-

sions and a number of ideas for future work.

2. The job shop scheduling constraint satisfaction

problem

The JSS problem can be posed with small

variations. In the present study, we consider the

problem as posed in [20]: the JSS requires sched-uling a set of jobs fJ1; . . . ; Jng on a set of physicalresources fR1; . . . ;Rqg. Each job Ji consists of a set

of tasks or operations fti1; . . . ; timig to be sequen-tially scheduled, and each task has a single re-

source requirement. We assume that every job has

a release date and a due date between which all the

tasks have to be performed. Each task has a fixed

duration duij and a start time stij whose value hasto be selected. The domain of possible start times

of the tasks is initially constrained by the release

and due dates.

Therefore, there are two non-unary constraints

of the problem: precedence constraints and capac-

ity constraints. Precedence constraints, defined by

the sequential routings of the tasks within a job,

translate into linear inequalities of the type:stil þ duil 6 stilþ1 (i.e. stil before stilþ1). Capacityconstraints, which restrict the use of each resource

to only one task at a time, translate into disjunc-

tive constraints of the form: stil þ duil 6 stjk _stjk þ dujk 6 stil (two tasks that use the same re-source cannot overlap). The objective is to come

up with a feasible solution, a solution being a

vector of start times, one for each task, such thatstarting at these times every job completes without

exceeding the due date and all the constraints are

satisfied. None of the simplifying assumptions are

required by the approach that will be discussed:

tasks might have several resource requirements

and several alternatives for each of these require-

ments. When the JSS is posed as an optimization

problem, several evaluation functions are usual tocompare solutions. In this work we consider the

most common: the makespan, that is the comple-

58 R. Varela et al. / European Journal of Operational Research 145 (2003) 57–71

tion time of the latest operation. This problem is

often referred to in the literature as the J==Cmaxproblem.

Fig. 1 depicts an example with three jobs

fJ1; J2; J3g and four physical resources fR1;R2;R3;R4g. It is assumed that the tasks of the first twojobs have a duration of two time units, whereas the

tasks of the third have a duration of three time

units. The release time is 0 and the due date is 10 for

every job. Label Pi represents a precedence con-straint and labelCj represents a capacity constraint.

Start time values constrained by the release and due

dates and the duration time of tasks are representedas intervals. For instance ½0; 4� represents all starttimes between time 0 and time 4, as allowed by the

time granularity, namely {0,1,2,3,4}.

We informally define a bottleneck as a resource

satisfying the following two properties:

(a) the resource appears at the same position, or at

least in a similar position, in the sequence ofvisited resources of each job and

(b) the average duration of the corresponding

tasks is greater than the average duration of

the remaining ones.

Fig. 2 shows (in text format as used by ourimplementation) a problem with two bottlenecks.

It is one of the 60 problems of the benchmark

proposed in [20], as the remaining it has 10 jobs

with 5 tasks each. As it was pointed out in [16] real

world problems often have some structure, so that

JSS problems with bottlenecks are not unrealistic.

For example, in many problems the flow of jobs

through the machines obeys a natural order ofassembly sequences, and the processing times of

operations on a machine correlate. These proper-

ties can be exploited by means of base heuristics in

order to improve the search procedure.

3. The genetic algorithm

Genetic algorithms appeared towards the end of

the 1960s and were intended to solve a number of

problems in industry that were difficult to solve

with the methods available at the time. In spite of

the fact that the mechanisms that drive the evo-

lution of species are not fully understood, some of

its features are well known, such as, for example,

the fact that evolution takes place in chromo-somes. Over different generations, chromosomes

are mixed, and only the best have a high chance of

survival. GAs try to imitate this behavior.

The basic iteration cycle of GAs [8,17] proceeds

on a population of individuals or chromosomes,

each one representing a point in the search space

of potential solutions to a given optimization

problem. An iteration cycle consists of two main

Fig. 1. A JSS problem instance with three jobs. The release

dates have value 0 for every job and the due dates have value

10. The duration of the tasks is indicated within the boxes to-

gether with the task identification and the resource requirement.

Fig. 2. A JSS problem instance of 10 jobs and 5 resources. Resources 2 and 4 are bottlenecks.

R. Varela et al. / European Journal of Operational Research 145 (2003) 57–71 59

steps: first a selection procedure and then a re-

combination. This cycle is repeated for a number

of generations. In order to evaluate the good

qualities of an individual, i.e. the degree of adap-

tation of the individual to the environment, the

fitness function is used. The value produced by thisfunction for an individual is used during the se-

lection procedure in such a way that an individual

has a selection probability for reproduction ac-

cording to its fitness value. Therefore, reproduc-

tion directs the search towards regions of the

search space where the average fitness of the

population improves.

On the other hand, the recombination step triesto reproduce the corresponding biological process;

the characteristics of a number of individuals are

mixed and mutated in order to generate offsprings.

In the GA environment, mainly two recombina-

tion operators are used: crossover and mutation.

GAs are intended to solve search and optimiza-

tion problems by reaching a solution which, though

not the best one, is at least a good approximation.GAs have been successfully used to solve, among

others, scheduling problems [3,12,16,18,22,24–26].

As we have pointed, we confront a class of these

problems: the JSS problem. In what follows, we

describe the GA proposed to this end. The codifi-

cation of individuals is permutation with repetition

proposed by Bierwirth [2]. According to this codi-

fication, an individual represents a permutation ofthe whole set of tasks of the problem at hand, in

which the relative order among the tasks of each job

is maintained. Consider for example the problem

depicted in Fig. 1 and the permutation of its tasks

ðt21 t31 t22 t11 t32 t12 t13 t23Þ. An individual is ob-

tained from this permutation by replacing the

identifier of each task by the number of its job;

therefore we obtain (2 3 2 1 3 1 1 2). Thus, thisrepresentation should be understood to mean the

following: the first 2 represents the first task of the

second job, the first 3 is the first task of the third job,

the second 2 is the second task of the second job,

and so on. The main reason for introducing this

representation of individuals is that every individual

produced by the genetic operators is feasible, as we

will see in the following paragraphs.The mutation operator we use in this study is

order-based mutation: two tasks are selected at

random and their positions are interchanged. At

the same time, we use generalized position cross-

over (GPX) proposed in [16]. In order to clarify

how GPX works, consider the following two par-

ents:

Parent1 ð1 2 2 1 2 1Þ; Parent2 ð1 1 2 2 1 2Þ:

A substring is selected at random from parent1,

for example the underlined substring that includes

the second 2 and the second 1, and these tasks are

deleted in parent2. Subsequently, the substring is

implanted in parent2, filling the same positions asin parent1. So, in this case we obtain the offspring

(1 2 2 1 1 2).

In order to define a fitness function, we have to

consider which is the potential solution that a

chromosome represents. Remember that a solu-

tion to a JSS problem is a schedule of the tasks

that satisfies every constraint of the problem, in-

cluding, of course, the completion of every job byits due date. Here, we consider that a potential

solution is a schedule of the tasks satisfying every

constraint except, perhaps, the completion of jobs

by their due dates. So a potential solution is ac-

tually a solution when this constraint is also sat-

isfied. In order to display the potential solution

represented by an individual and to establish a

rating among individuals, we consider two possi-bilities to build schedules from a given chromo-

some; in any case the fitness value is the makespan

of the schedule. In what follows, we shall refer to

as fitness1 and fitness2, respectively. It is clear that

the lower the fitness, the better the individual.

Hence, we have a minimization problem.

We shall now describe the scheduling strategies

of both fitness functions. In the first case, the se-quence of tasks is enumerated following the order

in which the tasks appear in the individual. For

each task, a start time is assigned which is calcu-

lated as the maximum end time of the previous

tasks in the sequence that are related to the task by

either a sequential constraint or a capacity con-

straint. On the other hand, the fitness2 scheduling

strategy consists in assigning the lowest possiblevalue as start time of a task, taking into account

the start times assigned to the previous tasks. Let

us clarify both strategies by means of an example.

Consider the individual (3 3 1 1 1 2 2 2), which


represents a potential solution to the problem ofFig. 1. Fig. 3(a) shows the schedule produced by

the fitness1 strategy, and Fig. 3(b) shows the cor-

responding schedule produced by the fitness2. The

fitness1 value is 13, whereas the fitness2 value is 11

for this chromosome. Hence this chromosome

does not represent a solution in any case.

It is clear that the fitness1 value is always

greater than or equal to the fitness2 value, but atthe same time the fitness2 algorithm is computa-

tionally more expensive. It is easy to see that

the former has a complexity of OðnÞ, whereas thelatter has a complexity of Oðn2Þ, n being the

number of tasks of the problem. On the other

hand, if we consider the number of different

schedules that can be obtained from the whole set

of possible individuals, this number is higher whenusing fitness1 than when using fitness2. Moreover,

as we shall see in Section 6, for every schedule that

can eventually be produced by the fitness2 proce-

dure, there is an individual that produces the same

schedule by means of the fitness1 strategy. The

fitness2 strategy produces an active schedule, that

is a schedule in which it is not possible for a left

shifting of a task without a right shifting ofanother task. Whereas the fitness1 produces semi-

active schedules, that is schedules in which it might

be possible to displace a task to the left without

displacing any other task and obtain a feasible

schedule. For example, in the schedule of Fig. 3(a)

the task t21 can be displaced to the left and as-signed a starting time of 0 or 1 obtaining a feasible

schedule. As it was proven that at least one of theoptimal schedules is an active schedule, both of the

strategies, fitness1 and fitness2, are complete.

The above-mentioned fitness functions can be

adjusted in order to better discriminate between

good and bad individuals. Here we consider thescaling. This is a common technique, as it is

pointed out in [17]. The objective is either to ac-

centuate or soften the difference between good and

bad chromosomes in order to obtain a more ac-

curate discrimination. The underlying idea is that

small relative differences in the fitness of good

and bad individuals do not facilitate the selection

of the best individuals and the elimination of theworse, whereas large relative differences might pro-

duce the dominance of semi-optima chromosomes

and hence the premature convergence of the GA.

Here, we consider a linear scaling which consists in

replacing the original fitness f by

f 0 ¼ f þ b; ð1Þb being a parameter which may be provided by the

user or automatically determined from the prob-

lem. In this work we propose a strategy to com-

pute the value of the parameter b. The objective is

to establish a constant relation Camong the best

and mean fitness values in every generation. Hencewe calculate the parameter b for a given generation

so that

C ¼ ðmeanþ bÞ=ðbest þ bÞ; ð2Þ

consequently, for each generation we will have

b ¼ ðmean� best � CÞ=ðC � 1Þ: ð3Þ

C is the scaling parameter, its value must be

greater than 1 and, in principle, is given by the user

as the reminder parameters of the GA. Setting these

parameters is something like an art and usually re-

quires a certain experience. Our current imple-

mentation requires the following parameters from

the user: /Crossover Probability/MutationProba-bility/Population Size/Number of Generations/

Fig. 3. (a) Schedule produced by the fitness1 strategy for the problem in Fig. 1 from the individual (3 3 1 1 1 2 2 2). The makespan is 13.

(b) Schedule produced from the same chromosome by the fitness2 strategy. The makespan is 11.


Number of Iterations/Scaling Parameter/Fitness

Function/Type of Initial Population/. We have se-

lected a number of these parameters from the ex-

perience, for example, a crossover probability of 0.7

is appropriate and a mutation probability of 0.1 is

also sufficient due to the mutation effect that theoperator GPX produces. Moreover, a scaling pa-

rameter of about 1.5 is also appropriate for our

experiments; the meaning of this value is that the

best chromosome is considered as 50% better than

a chromosome having the average fitness of the

population. The population size and number of

generations strongly depend on the size of the

problem.Hence values of about /100/50/ are enoughfor small problems, whereas values of about /200/

200/ ormore could be necessary for larger problems.

Even though it is well known that a classic GA

makes most of its work within the 50 first genera-

tions. The number of iterations is the number of

times that theGA is run to solve a problem instance.

From one run to the next the only change is the

random seed generation. The fitness function can beone of the former /F1/ or /F2/. And the initial

population can be chosen at random /RIP/ or heu-

ristic /HIP/, in this case a number of heuristic

chromosomes should be provided in a file, and the

remaining are generated at random. We usually

provide about one half of the population or less

heuristically and the other half is generated at ran-

dom in order to maintain an acceptable degree ofdiversity in the initial population.

4. Variable and value ordering heuristics

As we have pointed out in the introduction the

main contribution of this study is a method to

incorporate heuristic information in the initialpopulation of a conventional GA that solves JSS

problems. Our purpose is to exploit the variable

and value ordering heuristics proposed by Sadeh

and Fox in [20]. These heuristics are based on a

probabilistic model of the search space and were

aimed, in principle, to guide a classic state space

search [20,1]. Although they can be used in con-

junction with other search strategies, for examplein [10], these heuristics were used to select the next

machine to schedule in a shifting bottleneck pro-

cedure. A framework is introduced that accounts

for the likelihood that a given value will be as-

signed to a variable and the likelihood that values

assigned to different variables conflict with each

other.

These heuristics are evaluated from the profiledemands of the tasks for the resources. In partic-

ular, individual demand and aggregate demand

values are considered. The individual demand

DijðRp; T Þ of a task tij for a resource Rp at time T is

simply computed by adding the probabilities rijðsÞof the resource Rp demanded by the task tij at sometime within the interval ½T � duij þ 1; T �. The in-dividual demand is an estimation of the reliance ofa task on the availability of a resource. Consider,

for example, the initial state of the search to the

problem depicted in Fig. 1. As the task t12 has fivepossible start times or reservations, and assuming

that there is no reason to believe that one reser-

vation is more likely to be selected than another,

each reservation is assigned an equal probability to

be selected, in this case 1/5. Given that the task t12has a duration of 2 time units, this task will require

the resource R2 at time 4 if its start time is either 3or 4. So, the individual demand of the task t12 forresource R2 at time 4 is estimated as D12ðR2; 4Þ ¼r12ð3Þ þ r12ð4Þ ¼ 2=5. On the other hand, the ag-gregate demand DaggrðR; rÞ for a resource is ob-tained by adding the individual demands of all

tasks over time. Table 1 shows the individual de-mands of all 10 tasks of the problem, as well as the

aggregate demands for all four resources. A con-

tention peak is identified from the aggregate de-

mand of a resource. This is an interval of the

aggregate demand, whose duration is the average

duration of all the tasks, with the highest demand.

Table 1 shows the contention peaks of all the four

resources. Then, the task with the largest contri-bution to the contention peak of a resource is

determined as the most critical and consequently is

selected first for reservation. This is the heuristic

referred to in [20] as Operation Resource Reliance

(ORR).

On the other hand, the value ordering heuristic

proposed in [20] is also computed from the profile

demands for the resources. Given a task tij thatdemands the resource Rp, the heuristic consists in

estimating the survivability of the reservations.


The survivability of a reservation q ¼ hstij ¼ T i;survijðqÞ, is an estimation of the probability thatthe reservation will not conflict with the resource

requirements of other tasks, i.e. the probability

that none of the other tasks require the resourceduring the interval ½T ; T þ duij½.When the task demands are for only one re-

source, this probability is estimated as follows. At

any time T 6 s < T þ duij, there are npðsÞ � 1 un-scheduled tasks competing with task tij for re-source Rp, where npðsÞ is the number of tasks thatmight demand the resource Rp at time s. The totaldemand of these other unscheduled operations forRp is DaggrðRp; sÞ � DijðRp; sÞ. Assuming that eachof these other operations equally contributes to

this demand, the probability that none of these

operations requires Rp at time s is given by

1

�� DaggrðRp; sÞ � DijðRp; sÞ

npðsÞ � 1

�npðsÞ�1

: ð4Þ

Now we can approximate survijðqÞ as the

product of the probabilities that Rp will be avail-

able to tij on each one of the duij time intervalsbetween T and T þ duij, but this approximation isin general too pessimistic. It actually assumes that

any of these tasks could require Rp over time in-

terval ½s; s þ 1½ with independence of requiring theresource over time intervals ½s þ 1; s þ 2½ and

½s � 1; s½, which is only true when the tasks com-peting with tij have a duration equal to 1. Instead,because operations generally require time intervals

larger than 1, a better approximation can be

achieved by subdividing the duration of task tijinto buckets of duration duij=AVGðduÞ, whereAVG(du) is the average duration of the operations

competing for Rp. Hence, using Eq. (4) the sur-

vivability of the reservation q ¼ hstij ¼ T i can beapproximated as

survijðqÞ ¼ 1�

� AVGðDaggrðRp;sÞ�DijðRp;sÞÞ

=ðAVGðnpðsÞ� 1ÞÞ�AVGðnpðsÞ�1ÞduijðAVGðduÞÞ�1

;

ð5Þ

where AVGðDaggrðRp; sÞ � DijðRp; sÞÞ and AVGðnpðsÞ � 1Þ are, respectively, the averages of Daggr

ðRp; sÞ � DijðRp; sÞ and npðsÞ � 1 over time interval½T ; T þ duij½. Table 2 shows the survivability of allthe possible reservations for all ten tasks of theproblem. In principle, the value ordering heuristic

consists in trying those reservations with large

survivabilities first. However, some more refine-

ments are introduced in [20]: first, the number of

solutions to a relaxation of the problem which

are compatible with a reservation to a given task

is estimated to obtain the goodness of a reser-

vation. The goodness is more reliable than the

Table 1

Individual and aggregate demands of the initial state for the problem of Fig. 1 for all tasks and resources over the time intervals

The shadow regions correspond to the contention peaks of the respective resources.


survivability because it takes into account inter-

actions among tasks requiring different resources,

but at the same time it is more costly to calculate.

Finally the goodness is combined with a filtering

mechanism used to further refine the ranking of

reservations. The resulting heuristic is referred to

as Filtered Survivable Schedules (FSS). For a full

description of these heuristics, we refer the inter-ested reader to [20].

5. Heuristic initial population

In this section, we describe the strategy to build

up a heuristic initial population. Initialization in

GAs is an important issue, as proved in [3,9]. Eventhough some authors are wary of this technique

because it might produce premature convergence

due to the dominance of sub-optimal chromo-

somes; for example in [12] the initialization of a

GA with feasible chromosome lays out worse re-

sults than a random initialization in which most of

the chromosomes are not feasible. We propose two

different strategies to be used in conjunction inorder to generate initial chromosomes. We refer to

these strategies as heuristic-a and heuristic-b, re-

spectively. The aim of the former is to introduce

knowledge from the variable and value ordering

heuristics into the initial population. The idea is

first to consider the most critical resources, those

with the highest contention peaks, and then try to

place the tasks requiring these resources in a goodposition within the representation of chromo-

somes. We assume that a good position will be one

that probably translates into an assignment of the

starting time of the task to a value close to the time

with the highest survivability of the task. In orderto achieve such a distribution of tasks in the

chromosomes we propose the following strategy:

1. First, establish the critical resources as those re-

sources whose contention peaks are above the

average of the contention peaks of all the re-

sources. These will include the bottleneck and,

possibly, other resources.2. For each of the critical resources, establish the

critical tasks as the set of tasks that demand

the resource and order these tasks according

to their respective times of highest survivability.

3. Generate a set of individuals containing the crit-

ical tasks in the order determined above. Then,

distribute the remaining tasks within the indi-

vidual, taking only into account the sequentialconstraints of the problem, selecting at random

when there are more than one possibility.

The intuition behind heuristic-a is to assume

that the relative ordering among the critical tasks

accordingly to their times of maximum surviv-

ability is a good building block to generate chro-

mosomes. Regarding the former algorithm anumber of remarks should be considered. In step 1

the threshold from which a resource is considered

as critical might be other than the average value of

the contention peaks; here we have taken the av-

erage value as a default value. In step 2 it might

happen that the time of highest survivability of

two or more tasks is the same; in this situation we

can either select only one ordering with ties brokenat random, as done in our experiments, or consider

various orderings and then apply step 3 from each

one of them. The later possibility seems to be more

Table 2

Survivabilities of all 10 tasks in the initial state for the problem of Fig. 1 over the time intervals

1 2 3 4 5 6 7 8 9 10

t11 0.75 0.57 0.48 0.48 0.57

t12 0.6 0.6 0.7 0.89 1

t13 0.42 0.3 0.3 0.36 0.54

t21 1 0.89 0.7 0.6 0.6

t22 1 1 1 1 1

t23 0.4 0.3 0.3 0.36 0.54

t31 0.61 0.54 0.54 0.61 0.75

t32 0.54 0.35 0.27 0.27 0.35


appropriate because it introduces more promising

building blocks, but on the other hand it is com-

putationally more expensive. In any case it might

happen that two or more chromosomes generated

in this way turn out to be the same.

On the other hand, the heuristic-b strategy con-sists in rebuilding an individual representation in

such a way that both of the scheduling strategies,

fitness1 and fitness2, produce the same schedule.

This is a heuristic repair method that transforms an

individual into another one that is better or, in the

worst case, equal to the original. In this case, the

purpose is that some time holes that the fitness1

strategy might waste for a given chromosome areused in the transformed representation.

Let us clarify the application of both heuristics

by means of an example. Consider the problem

depicted in Fig. 1. As it is shown in Table 1, the

most critical resource is R3, which is required bythe set of tasks ft13; t23; t32g. If we sort this set (thecritical tasks) according to the times of maximum

survivabilities, the result is either ðt32; t13; t23Þ orðt32; t23; t13Þ. Therefore, in accordance with the

strategy of heuristic-a, from the first ordering we

could generate the permutation ðt31 t32 t11 t12 t13 t21t22 t23Þ or ðt11 t31 t32 t21 t12 t13 t22 t23Þ. These per-mutations translated into the chromosome nota-

tion are (3 3 1 1 1 2 2 2) and (1 3 3 2 1 1 2 2),

respectively. At the same time, from the second

ordering we could generate the chromosome ðt31 t21t22 t11 t32 t12 t23 t13Þ or (3 2 2 1 3 1 2 1). Fig. 3 depictsthe schedule produced from the first one of the

former individuals by the fitness1 and fitness2 func-

tions, respectively.

From the schedule of Fig. 3(b), and following

heuristic-b, we can build an individual whose fit-

ness1 value is equal to the fitness2 value of the

original by simply ordering the tasks according tothe values of their starting times in said schedule.

This individual is ðt21 t31 t22 t11 t32 t12 t13 t23Þ or (2 32 1 3 1 1 2) which is finally inserted as a new in-

dividual of the heuristic initial population. As we

can see, the relative ordering among the critical

tasks is maintained after reconstruction. There-

fore, the intuition behind heuristic-b is that it can

maintain the building blocks as long as the re-maining tasks are reorganized so that the schedule

improves.

The overall approach to obtain the initial pop-

ulation consists in generating a fraction of the

chromosomes by first applying the heuristic-a

strategy and then reconstructing them by means of

heuristic-b. The remaining chromosomes are gen-

erated at random in order to guarantee the diver-sity of the population.

6. Experimental results

This section reports the results of an experi-

mental study comparing various versions of our

genetic algorithm. As we have pointed out, weconsider problem instances from two different

benchmarks. First the test of data of 60 problems

proposed in [20]. As far as we have known, this is

the only public benchmark including JSS problems

with bottlenecks. At the moment, we discard other

best known repositories, like the OR library, be-

cause they do not include problems with bottle-

necks. Instead, what we have done in this work isto propose a new test of data with medium and

large instances of JSS problems with bottlenecks.

In both of the cases we report results showing that

a conventional GA really improves its perfor-

mance when the initial population is seeded with

heuristic chromosomes.

6.1. The test of data of Norman Sadeh

These problems were randomly generated, each

with five resources and 10 jobs of five operations.

Each job has to visit each of the five resources, and

the order of visiting was randomly generated ex-

cept for the bottleneck resources, which were each

visited after a fixed number of operations. Twoparameters were used to cover different scheduling

conditions: RG, a range parameter, controlled the

distribution of release dates and due dates, and a

bottleneck parameter, BK, controlled the major

bottleneck resources. Three values of RG were

used (0.0, 0.1 and 0.2). When RG is 0.0, all release

dates are the same, as are the due dates. For higher

values of RG, different values are determined froma uniform probability distribution parameterized

by RG. Two values of BK were considered (1 and


2) determining the number of bottleneck resources.Hence, six groups of 10 problems were generated.

Table 3 shows the best solutions found for all

the 60 problems running the GA algorithm with

the parameters /100/100/100/0.7/0.1/1.6/F2/HIP/.

In any case the heuristic initial population was of

about 50 chromosomes and was computed con-

sidering the original due date of each problem in-

stance. In almost every case the best solutionfound is much lower than the due dates of the

problem instance, hence it can be expected that is

quite easy to found a feasible even though non-

optimal solution to every problem. Then in the

next experiment we try to obtain a solution at least

as good as the best solution reached in this ex-

periment.

Table 4 summarizes the results of an experi-mental study considering both of the fitness func-

tions, fitness1 and fitness2, as well as random and

heuristic initial populations. We show the number

of experiments that reach the best solution ob-tained in the previous experiment as well as the

average values of the mean relative error and the

standard deviation in percent for each of the 6

subsets of problems generated from the same val-

ues of parameters RG and BK. The relative error

is calculated for each run as

100 � ðbest � knownÞ=known; ð6Þ

where best is the best solution found in a single run

of the GA and known is the solution showed in

Table 3 for the same problem instance. As we can

observe, problems with 2 bottlenecks are harder

to solve than problems with only one. This fact is

confirmed for all of the three measurements given.

Moreover, when the GA is biased by means of aheuristic initial population it outperform the

variant with random initial population. And the

improvement introduced by the heuristic individ-

uals is more significant for problems with two

Table 3

Best solutions found to the 60 problems of the test of data proposed by Sadeh

Subset of problems Problem instance within the subset

1 2 3 4 5 6 7 8 9 10

e0ddr1 (RG¼ 0.0, BK¼ 1) 140 135 146 137 136 127 139 144 129 143

e0ddr2 (RG¼ 0.0, BK¼ 2) 157 162 150 141 141 145 151 146 163 138

enddr1 (RG¼ 0.1, BK¼ 1) 140 142 146 139 140 129 141 150 132 145

enddr2 (RG¼ 0.1, BK¼ 2) 158 167 151 144 153 155 154 152 165 145

ewddr1 (RG¼ 0.2, BK¼ 1) 143 145 147 143 142 130 143 153 137 147

ewddr2 (RG¼ 0.2, BK¼ 1) 161 168 152 148 160 164 157 158 166 148

Table 4

Summary of an experimental study on the test of data proposed by Sadeh

Subset of problems Fitness1 Fitness2

RIP HIP RIP HIP

NBS MRE S.D. NBS MRE S.D. NBS MRE S.D. NBS MRE S.D.

e0ddr1 9 1.09 1.61 10 0.42 0.79 10 0.13 0.41 10 0.02 0.09

e0ddr2 0 8.23 3.79 2 6.33 3.26 5 3.8 2.3 8 1.41 1.08

enddr1 9 2.1 2.45 9 0.34 0.76 10 0.06 0.26 10 0.01 0.06

enddr2 1 8.95 4.29 4 7.34 3.66 5 3.8 2.2 10 1.37 1.4

ewddr1 6 4.03 3.55 10 0.99 1.74 10 0.2 0.38 10 0.02 0.04

ewddr2 0 11.61 5.5 0 8.18 4.9 3 3.86 2.41 8 1.56 1.27

For each of the 6 subsets generated from the same values of parameters RG and BK we show the number of problem instances for

which the best known solution is reached (NBS) as well as the average values of the mean relative error (MRE) and standard deviation

in percent (S.D.). We consider 4 variations of the GA by combining fitness1 and fitness2 functions with random (RIP) and heuristic

(HIP) initial populations. The remainder parameters are /100/50/50/1.4/ when RIP is used and /100/50/50/1.6/ when HIP is used.


bottlenecks than for problems with only one. As

we can see, the only approach that almost solves

every instance to the best solution known is the

last one that combines active scheduling with the

heuristic initial population.

6.2. Our proposed test of data

This test of data includes 12 problems of dif-

ferent sizes and number of bottleneck resources.

Three problems were generated with 10 jobs and

10 operations each (size 10� 10), with 2, 3 and 4bottleneck resources, respectively. Three 20� 20problems with 3, 5 and 7 bottlenecks, respectively.

Three 30� 30 problems with 3, 6 and 9 bottle-necks, respectively, and three 40� 40 problemswith 5, 10 and 14 bottlenecks, respectively. In any

case the processing time of the operations was

randomly generated within a given range. For the

operations requiring bottleneck resources the

range was [100, 195], whereas for the remainingoperations the range was [5, 100]. Every release

date was set to 0, and the due date is the same for

every job of each problem. These due dates were

established from a set of experiments: first the GA

algorithm was run for every problem with the

following parameters /100/140/100/0.7/0.1/1.4/F2/

RIP/. Hence a number of about 10 000 chromo-

somes were evaluated during a single running. Inprinciple, the best solution found to every problem

is taken as the due date. Then, we calculate a set of

about 50 heuristic chromosomes for each of the

problems and run again the GA, this time with the

parameters /100/140/100/0.7/0.1/1.6/F2/HIP/. That

is, by using a heuristic initial population and a

scaling factor a little bit larger in order to give

higher weigh to the heuristic chromosomes. Fi-nally, the best makespan found in this experiment

for each of the problems is chosen as its due date.

Table 5 shows the results obtained with the four

variations of the GA run over a really small

number of generations (50) for the problem sizes.

This way we can observe the short term behavior

of the GA and hence to better appreciate the effect

of seeding the initial population with heuristicchromosomes. As we can see, in every case the best

solution reached with heuristic initial population is

better than the one obtained with the random

initial population counterpart. And the difference

augments with the problem size, being especially

remarkable for the biggest problems when semi-

active scheduling is used. Moreover, for these

problems the GA using semi-active scheduling and

heuristic initial population clearly outperforms theGA variation using active scheduling and random

initial population.

In addition to the results concerning the best

solution reached, the values of the mean relative

error and standard deviation are of great interest.

These values are meaningful about the stability of

the GA that in any case it can be expected to be

moderate due to the low number of generations ofthe experiments. As we can observe, MRE and S.D.

values aremuch lower when the initial population is

biased with heuristic chromosomes. Hence, we can

conclude that the performance of the GA improves

by biasing the initial population with heuristic

knowledge from the problem domain, at least dur-

ing the first 50 generations. Aswe have seen, the best

solution is found as well as the stability improves.Now we consider the long term evolution of the

GA. Even though the heuristic initial population

improves the performance at the short term, the

situation could be quite different at the long term.

It can appear as the well known effect of premature

convergence, that is, the rapid convergence of the

GA towards a region of sub-optimal solutions due

to the dominance of sub-optimal chromosomes.Hence preventing the GA from the ability of ex-

ploring other regions of the search space with

optimal or near-optimal solutions. To study the

long term performance we first run the GA over a

number of 200 generations and show in Table 6

the results. As it can be expected the quality of

the solutions improves and in any case the re-

sults obtained with a version with heuristic initialpopulations outperform the random counterpart.

Moreover in neither case a random version with

200 generations outperforms the corresponding

heuristic one with only 50 generations and this is

much more clear for the largest problem instances.

Then we solve the last problem instance up to a

number of 1000 generations and report in Table 7

the results together with the results with 50 and200 generations. As we can observe, even after

1000 generations the version with random initial


population can not outperform the heuristic onewhen running up to 50 generations.

Regarding the run time of experiments, on one

hand we have to consider the run time of the GA

and, on the other hand, the run time required to

build up a heuristic initial population. The run time

required for a running of the GA depends on theproblem size, population size, number of genera-

tions and the scheduling strategy. In the experi-

ments reported in Table 4, the time for a running

on a 10� 5 problem using active scheduling was

about 0.33 seconds. In the experiments on our

Table 5

Summary of the results of the experimental study of the test of data proposed in this paper

Problem

instance

Known

solutionFitness1 Fitness2

RIP HIP RIP HIP

BS MRE S.D. BS MRE S.D. BS MRE S.D. BS MRE S.D.

P_10� 10_2R 1926 2024 11.13 2.9 1967 2.13 0.0 1943 2.76 1.27 1935 1.97 0.36

P_10� 10_3R 2039 2192 16.58 4.1 2077 1.88 0.54 2082 5.82 1.73 2058 1.4 0.45

P_10� 10_4R 2403 2887 30.1 4.56 2487 5.49 1.0 2486 6.15 1.56 2454 4.77 1.16

P_20� 20_3R 4099 5323 41.38 5.01 4283 6.26 0.61 4289 9.19 1.53 4158 3.47 1.12

P_20� 20_5R 4311 6013 51.44 5.79 4494 5.17 0.41 4679 13.02 1.81 4346 2.93 0.73

P_20� 20_7R 4762 7933 85.3 7.73 4975 5.84 0.41 5271 15.13 1.42 4843 3.18 0.69

P_30� 30_3R 5879 8455 59 5.99 6067 5.04 0.68 6340 11.9 1.26 5939 2.65 0.95

P_30� 30_6R 6786 12 477 103.4 6.76 6987 3.89 0.38 7451 12.18 1.18 6870 1.98 0.47

P_30� 30_9R 7185 12 762 94.7 9.34 7588 6.5 0.42 8077 15.15 1.19 7311 3.5 0.87

P_40� 40_5R 8413 13 834 80.67 7.96 8758 5.9 0.57 9376 14.21 1.23 8485 2.39 0.62

P_40� 40_10R 9613 20 380 140.4 10.5 9925 3.38 0.08 10 855 15.52 1.15 9721 1.95 0.3

P_40� 40_14R 10 324 25 549 165 8.52 10 705 4.05 0.17 11 917 17.7 0.95 10 410 1.76 0.48

For each of the 12 problems the name shows the size of the problem as well as the number of bottleneck resources. The best solution

known is found by running the GA with the following parameters /100/200/100/0.7/0.1/1.6/F2/HIP/. The due dates used to compute the

heuristic initial population were first obtained by running the GA with /100/140/0.7/0.1/1.4/F2/RIP/. The reminder results were

obtained with four variants of the GA with the first parameters as /100/50/50/0.7/0.1/ and the last ones by taking the values /1.4/F1/

RIP/, /1.6/F1/HIP/, /1.4/F2/RIP/ and /1.6/F2/HIP/, respectively. In any case the values of the best solution found (BS), the mean

relative error (MRE) and standard deviation in percent (S.D.) are reported.

Table 6

Summary of the experiment carried out with the same parameters of the experiment reported in Table 5, except that the number of

generations that in this case is increased from 50 to 200

Problem

instance

Known

solution

Fitness1 Fitness2

RIP HIP RIP HIP

BS MRE S.D. BS MRE S.D. BS MRE S.D. BS MRE S.D.

P_10� 10_2R 1926 1959 5.5 2.43 1964 2.1 0.05 1926 2.05 1.29 1935 1.82 0.44

P_10� 10_3R 2039 2061 7.44 2.77 2077 1.8 0.00 2049 4.21 1.27 2043 1.05 0.26

P_10� 10_4R 2403 2575 15.77 3.77 2487 3.68 0.54 2412 4.76 1.96 2437 3.6 1.18

P_20� 20_3R 4099 4858 26.1 3.32 4183 4.37 0.91 4242 6.81 1.34 4097 3.32 0.90

P_20� 20_5R 4311 5132 29.6 3.24 4419 3.93 0.58 4552 10.3 1.60 4347 2.1 0.48

P_20� 20_7R 4762 6894 56.67 4.29 4911 4.6 0.51 5168 13.21 1.83 4792 2.3 0.72

P_30� 30_3R 5879 7752 41.74 4.04 6027 3.5 0.52 6238 9.3 1.32 5896 1.75 0.89

P_30� 30_6R 6786 11 078 76.17 3.47 6935 2.74 0.39 7212 10.05 1.13 6820 1.55 0.46

P_30� 30_9R 7185 10 907 66.06 4.97 7502 5.34 0.27 7823 12.62 1.51 7268 2.69 0.989

P_40� 40_5R 8413 11 705 57.28 5.21 8647 4.23 0.59 9066 11.71 1.25 8438 1.65 0.71

P_40� 40_10R 9613 17 305 103.5 5.33 9856 3.07 0.25 10 521 13.42 1.16 9613 1.5 0.54

P_40� 40_14R 10 324 21 240 125.1 4.32 10 642 3.54 0.19 11 728 15.7 1.07 10 334 1.3 0.47


proposed test with population size of 100 chro-mosomes and 50 generations and active scheduling,

the required times were about: 0.75 seconds for

10� 10 problems, 3 seconds for 20� 20 problems,7.25 seconds for 30� 30 problems and 14 secondsfor 40� 40 problems. For the experiment with1000 generations reported in Table 7 the required

run time was about 275 seconds. In any case the

run time is reduced to about 25% when using asemi-active scheduling strategy. On the other hand,

the time required to compute the heuristic initial

population is mainly the time required to compute

the survivabilities. In this work we have used a

prototype implementation that computes exactly

the profile demands and the value of expression (4)

to obtain the survivabilities, without taking into

account some approximations, used, for examplein [1], that can considerably reduce the required run

time; and at the same time computes the surviv-

abilities for every task even though the only ones

required are those of the tasks requiring critical

resources. By using this prototype, the required run

times to obtain heuristic initial populations take

values of about 4, 25, 80 and 250 seconds for

problem instances with sizes 10� 10, 20� 20,30� 30 and 40� 40, respectively. Here we have toconsider that these running times can be signifi-

cantly reduced, and that even with these times it is

worth exploiting the heuristic knowledge to seed

the initial population. As we can observe from the

running up to 1000 generations reported in Table 7,

the time required (275 seconds) is larger than the

time required for a running up to 50 generations(14 seconds) plus the time required to compute the

heuristic chromosomes (250 seconds), whereas the

performance is much better in the second case. All

of the experiments were made on a Pentium III

CPU at 750 MHz.

7. Final remarks

In this paper we have presented a method to

improve the performance of a GA in solving JSS

problems. The experimental results reported show

that GAs can profit from other search techniques

such as the probability-based heuristics proposed

in [20]. In particular, we present a method suitablefor a family of problems: the JSS with bottlenecks,

a sub-family of JSS problems with many real in-

stances as described in [16]. The approach pro-

posed here has some limitations derived from the

heuristic information exploited: the survivability

of the reservations. As we have seen in Section 4,

survivabilities are computed from the time do-

mains and duration of the tasks requiring the sameresources. That is, not taking into account inter-

actions with the reminder tasks. This means that

we assume a relaxation of the problem that elim-

inates the precedence constraints and consequently

the sub-problem of building a partial schedule for

one resource is independent of the reminding re-

sources. What can be considered true to some ex-

tent for bottleneck resources as they are defined inthis paper, but not in general. Hence, in order to

extend our strategy to other problems, we have to

consider a weakness relaxation of the problem and

other heuristics like those proposed in [14]. For

example, we can exploit the goodness as defined in

[20] which takes into consideration the number of

solutions that a given reservation leaves for the

remaining tasks of the same job.We have proved that a GA can be improved by

introducing knowledge domain obtained from the

structure of the problem. As the experimental re-

sults shown, the GA converges appropriately and

produces better solutions. And, on the other hand,

the premature convergence that could be produced

Table 7

Summary of the results obtained to the problem instance P_40� 40_14R with the same parameters as in the experiments reported inTables 5 and 6 but considering three different number of generations: 50, 200 and 1000, and in any case fitness2 scheduling

Number of generations Known

solution

RIP HIP

BS MRE S.D. BS MRE S.D.

50 10 324 11 917 17.7 0.95 10 410 1.76 0.48

200 10 324 11 728 15.7 1.07 10 334 1.3 0.47

1000 10 324 11 574 14.54 1.22 10 337 0.89 0.5


by dominance of sub-optimal solutions is not ob-

served. In our experimental study we have con-

sidered, in principle, the test proposed by Sadeh in

[20]. These problems have resulted to be very easy

to solve by a GA due to the due dates that are, in

general, much larger than the completion timesrequired by the optimal solution; hence we have

established a lower bound for a feasible solution.

Then by considering these new lower bounds, the

experiments have confirmed that the performance

of the GA is much better when it is initialized with

heuristic chromosomes. In any case, the problem

instances of the former test are actually very small,

hence we have experimented also on a number oflarger problem instances. As we have not found

problems with bottlenecks on the usual sites like

for example the OR library, we have proposed our

own test with medium and large problem in-

stances. These problem instances as well as the

prototype implementation of the GA used in the

experiments can be downloaded from the web site

http://www.aic.uniovi.es/AG/almacen.htm. Theexperimental results shown that our approach not

only still works efficiently but the improvement is

more meaningful as long as both the size of the

problem and the number of bottleneck resources

increase.

Acknowledgement

We wish to thank Norman Sadeh for facilitat-

ing access to his 60 problems benchmark.

References

[1] J.Ch. Beck, M.S. Fox, Dynamic problem structures anal-

ysis as a basis for constraint-directed scheduling heuristics,

Artificial Intelligence 117 (2000) 31–81.

[2] Ch. Bierwirth, A generalized perutation approach to job

shop scheduling with genetic algorithms, OR Spektrum 17

(1995) 87–92.

[3] Ch. Bierwirth, D.C. Mattfeld, Production scheduling and

rescheduling with genetic algorithms, Evolutionary Com-

putation 7 (1) (1999) 1–17.

[4] J. Blazewicz, W. Domschke, E. Pesch, The job shop

scheduling problem: Conventional and new solution tech-

niques, European Journal of Operational Research 93

(1996) 1–33.

[5] R.W. Conway, W.L. Maxwell, L.W. Miller, Theory of

Scheduling, Addison-Wesley, Reading, MA, 1967.

[6] U. Dorndorf, E. Pesch, Evolution based learning in a job

shop scheduling environment, Computers and Operations

Research 22 (1995) 25–40.

[7] H.L. Fang, P. Ross, D. Corne, A promising genetic

algorithm approach to job-shop scheduling, rescheduling,

and open-shop scheduling problems, in: Proceedings of the

Fifth International Conference on Genetic Algorithms,

1993, pp. 375–382.

[8] D. Goldberg, Genetic Algorithms in Search, Optimization

and Machine Learning, Addison-Wesley, Reading, MA,

1985.

[9] J.J. Grefenstette, Incorporating problem specific knowl-

edge in genetic algorithms, in: Genetic Algorithms and

Simulated Annealing, Morgan Kaufmann, Los Altos, CA,

1987, pp. 42–60.

[10] H.H. Holtsclaw, R. Uzsoy, Machine criticality measures

and sub-problem solution procedures in shifting bottleneck

methods: A computational study, Journal of the Opera-

tional Research Society 47 (1996) 666–677.

[11] A.S. Jain, S. Meeran, Deterministic job-shop scheduling:

Past, present and future, European Journal of Operational

Research 113 (1999) 390–434.

[12] M. Khouja, Z. Michalewicz, M. Wilmot, The use of genetic

algorithms to solve the economic lot size scheduling

problem, European Journal of Operational Research 110

(1998) 509–524.

[13] M. Kolonko, Some new results on simulated annealing

applied to the job shop scheduling problems, European

Journal of Operational Research 113 (1999) 123–

136.

[14] J. Larrosa, P. Messeguer, Generic CSP Techniques for the

Job-Shop Problem, in: J. Mira, A.P. del Pobil, M. Ali

(Eds.), Methodology and Tools in Knowledge-Based

Systems, Lecture Notes in Artificial Intelligence, 1415,

Springer, Berlin, 1998, pp. 46–55.

[15] B.L. Maccarthy, J. Liu, Addressing the gap in scheduling

research: a review of optimization and heuristic methods in

production scheduling, International Journal of Produc-

tion Research 31 (1) (1993) 59–79.

[16] D.Ch. Mattfeld, Evolutionary Search and the Job Shop.

Investigations on Genetic Algorithms and Production

Scheduling, Springer, Berlin, 1995.

[17] Z. Michalewicz, Genetic Algorithms+Data Structures ¼Evolution Program, Second, Extended Edition, Springer-

Verlag, Berlin, 1994.

[18] J. Parre~nno, A. G�oomez, P. Priore, FMS loading and

Scheduling problem solving using genetic algorithms, in:

INFORMS XXXIV, Barcelona, 1997, pp. 156–166.

[19] F. Pezzella, E. Merelli, A tabu search method guided by

shifting bottleneck for the job shop scheduling problem,

European Journal of Operational Research 2 (120) (2000)

297–310.

[20] N. Sadeh, M.S. Fox, Variable and value ordering heuristics

for the job shop scheduling constraint satisfaction prob-

lem, Artificial Intelligence 86 (1996) 1–41.


http://www.aic.uniovi.es/AG/almacen.htm

[21] R.H. Storer, S.D. Wu, R. Vaccari, Local search in problem

space for sequencing problems, in: G. Fandel, T. Gulledge,

A. Jones (Eds.), New Directions for Operations Research

in Manufacturing, Springer Verlag, Berlin, 1992, pp. 587–

597.

[22] G. Syswerda, Schedule optimization using genetic algo-

rithms, in: L. Davis (Ed.), Handbook of Genetic Algo-

rithms, Van Nostrand Reinhold, New York, 1991, pp.

1332–1349.

[23] R.J.M. Vaessens, E.H.L. Aarts, J.K. Lenstra, Job shop

scheduling by local search, Working paper, University of

Technology, Eindhoven, 1995.

[24] R. Varela, A. G�oomez, C.R. Vela, J. Puente, C. Alonso,

Heuristic Generation of the Initial Population in Solving

Job Shop Problems by Evolutionary Strategies, in: Foun-

dations and Tools for Neural Modeling, Lecture Notes in

Computer Science, Proceedings of the International Work-

Conference on Artificial and Natural Neural Networks,

IWANN�99, Alicante, Spain, vol. I, Springer-Verlag,Berlin, June 1999.

[25] R. Varela, C.R. Vela, J. Puente, A. G�oomez, A.M. Vidal,

Solving job-shop scheduling problems by means of genetic

algorithms, in: L. Chambers (Ed.), The Practical Hand-

book of Genetic Algorithms, Ch. 8., Chapman and Hall/

CRC, London, 2001, pp. 275–293.

[26] T. Yamada, R. Nakano, Scheduling by genetic local

search with multi-step crossover, in: Fourth International

Conference On Parallel Problem Solving from Nature

(PPSN IV), Berlin, Germany, 22–26 Sep., 1996, pp. 960–

969.


Documents

A knowledge-based evolutionary strategy for scheduling problems with bottlenecks