A Survey of Parallel Distributed Genetic Algorithms - Semantic Scholar

3 downloads 175 Views 254KB Size Report
Enrique Alba. Dpto. de Lenguajes y CC.CC. Universidad de Málaga. Campus de Teatinos (2.2.A.6). 29071-Málaga (ESPAÑA) [email protected]. José M. Troya.
A Survey of Parallel Distributed Genetic Algorithms Enrique Alba

José M. Troya

Dpto. de Lenguajes y CC.CC. Universidad de Málaga Campus de Teatinos (2.2.A.6) 29071-Málaga (ESPAÑA) [email protected]

Dpto. de Lenguajes y CC.CC. Universidad de Málaga Campus de Teatinos (2.2.A.13) 29071-Málaga (ESPAÑA) [email protected]

ABSTRACT In this work we review the most important existing developments and future trends in the class of Parallel Genetic Algorithms (PGAs). PGAs are mainly subdivided into coarse and fine grain PGAs, the coarse grain models being the most popular ones. An exceptional characteristic of PGAs is that they are not just the parallel version of a sequential algorithm intended to provide speed gains. Instead, they represent a new kind of meta-heuristics of higher efficiency and efficacy thanks to their structured population and parallel execution. The good robustness of these algorithms on problems of high complexity has led to an increasing number of applications in the fields of artificial intelligence, numeric and combinatorial optimization, business, engineering, etc. We make a formalization of these algorithms, and present a timely and topic survey of their most important traditional and recent technical issues. Besides that, useful summaries on their main applications plus Internet pointers to important web sites are included in order to help new researchers to access this growing area.

Keywords: Parallel genetic algorithms (PGAs), Evolution topics, Migration, PGA classification, Overview of technical issues, Future trends

[Contact author: Enrique Alba ]

A Survey of Parallel Distributed Genetic Algorithms ABSTRACT In this work we review the most important existing developments and future trends in the class of Parallel Genetic Algorithms (PGAs). PGAs are mainly subdivided into coarse and fine grain PGAs, the coarse grain models being the most popular ones. An exceptional characteristic of PGAs is that they are not just the parallel version of a sequential algorithm intended to provide speed gains. Instead, they represent a new kind of meta-heuristics of higher efficiency and efficacy thanks to their structured population and parallel execution. The good robustness of these algorithms on problems of high complexity has led to an increasing number of applications in the fields of artificial intelligence, numeric and combinatorial optimization, business, engineering, etc. We make a formalization of these algorithms, and present a timely and topic survey of their most important traditional and recent technical issues. Besides that, useful summaries on their main applications plus Internet pointers to important web sites are included in order to help new researchers to access this growing area.

1. INTRODUCTION &

A genetic algorithm (GA) [26], [36] is a heuristic used to find a vector x * (a string) of free parameters with values in an admissible region for which an arbitrary quality criterion is optimized: &  & & & f ( x ) → max : find an x * such that (1) ∀x ∈ M : f ( x ) ≤ f ( x*) = f * A sequential GA (Figure 1) proceeds in an iterative manner by generating new populations of strings from the old ones. Every string is the encoded (binary, real, ...) version of a tentative solution. An evaluation function associates a fitness measure to every string indicating its suitability to the problem. The algorithm applies stochastic operators such as selection, crossover and mutation on an initially random population in order to compute a whole generation of new strings. Initialize population // With randomly generated solutions Repeat t = 1, 2, ... // Reproductive loop Evaluate solutions in the population Perform competitive selection Apply variation operators Until convergence criterion satisfied Figure 1. Pseudo-code of a sequential genetic algorithm. Unlike most other optimization techniques, GAs maintain a population of tentative solutions that are competitively manipulated by applying some variation operators to find a global optimum. For nontrivial problems this process might require high computational resources (large memory and search times, for example), and thus a variety of algorithmic issues are being studied to design efficient GAs. With this goal numerous advances are continuously being achieved by designing new operators, hybrid algorithms, termination criteria, and more [10]. We revisit and survey one of such improvements consisting in using parallel models of GAs (PGAs) [16], [17].

-1-

PGAs are not just parallel versions of sequential genetic algorithms. In fact they actually reach the ideal goal of having a parallel algorithm whose behavior is better than the sum of the separate behaviors of its component sub-algorithms, and this is why we directly focus on them. Several arguments justify our work. First of all, PGAs are naturally prone to parallelism since the operations on the strings are relatively independent from each other. Besides that, the whole population (panmixia) can be geographically structured [32], [55], [65] to localize competitive selection between string subsets, often leading to better algorithms. The evidences of a higher efficiency [31], [66], larger diversity maintenance [44], [50], additional availability of memory and CPU, and multi-solution capabilities [14], reinforce the importance of the research advances in the field of PGAs. Using parallel GAs often leads to superior numerical performance (not only to faster algorithms) even when the algorithms run on a single processor [31], [34]. However, the truly interesting observation is that the use of a structured population, either in the form of a set of islands [68] or a diffusion grid [65], is responsible for such numerical benefits. As a consequence, many authors do not use a parallel machine at all to run structured-population models, and still get better results than with serial GAs [4], [31], [45]. Hardware parallelization is an additional way of speeding up the execution of the algorithm, and it can be attained in many ways on a given structured-population GA. Hence, once a structured-population model is defined, it could be implemented in any uniprocessor or parallel machine. There exist many examples of this modern vision of parallel GAs, namely, a ring of panmictic GAs on a MIMD computer, a grid of individuals on uniprocessor/MIMD/SIMD computers, and many hybrids (see Section 3 for more details). We mainly focus on distributed implementations since clusters of workstations and similar hardware are very popular and accessible platforms (the impact of the research is potentially very large). In this work we present some background for the research with sequential and parallel GAs. Also we identify their current and future implications, as well as some unresolved issues. Section 2 contains introductory material providing the nomenclature, and some general working principles of sequential GAs. Section 3 offers an introduction to parallel GAs and formalizes the work of a parallel GA, while Section 4 summarizes some existing theories about why and how they work. In Section 5 we give some hints to help classification in such a diverse field, and explicitly present a detailed survey. Section 6 contains the formalization of the main technical issues concerning parallel GAs, and it outlines future trends. Finally, in Section 7 we discuss some implementation considerations, and Section 8 gives some concluding remarks. We add an extensive bibliography to help the reader in finding useful starting pointers.

2. SEQUENTIAL GENETIC ALGORITHMS Before starting off by discussing sequential GAs we will put in context these algorithms. Afterwards, we will offer a review of the nomenclature, the representation issues, and the basic internal operations of a canonical GA in this section. We develop our study in the field of GAs since they are quite popular and receive many applications, and also because many results on GAs are extensible to other EAs (evolutionary algorithms) in general. See [11], [24], [58] for learning about the origin and similarities among the different EA families. The Figure 2 details the well-accepted sub-classes of EAs, namely genetic algorithms (GA), evolutionary programming (EP), evolution strategies (ES), genetic programming (GP), and classifier systems (CS). In [10] the reader can found a great compendium of the state of the art in evolutionary computing.

-2-

After some recent works, the fields of evolutionary computing, neural networks, and fuzzy logic, are listed together as techniques looking for solving problems by using numeric knowledge representation, in opposition to traditional artificial intelligence, where symbolic knowledge representation is used. This broader research field is known as Computational Intelligence or Soft Computing [15], and it is gaining acceptance (recent international journals and conferences). GA

Computational Intelligence

EP

Evolutionary Computing

ES

Artificial Neural Networks

GP

Fuzzy Logic

CS

Figure 2. Location of the different families of evolutionary algorithms. Since GAs apply operations drawn from nature, the nomenclature used in this field is closely related to the terms we can find in biology. Table I summarizes the meaning of these special terms in the aim of helping novel researchers. TABLE I. NOMENCLATURE Genotype Chromosome Individual Gene Allele Locus Phenotype Fitness Environment Population Selection Crossover Mutation

The code, devised to represent the parameters of the problem in the form of a string One encoded string of parameters (binary, Gray, floating point numbers, etc...) One or more chromosomes with an associated fitness value The encoded version of a parameter of the problem being solved Value which a gene can assume (binary, integer, real, or even complex data structures) The position that the gene occupies in the chromosome Problem version of the genotype (algorithm version), suited for being evaluated Real value indicating the quality of an individual as a solution to the problem The problem. This is represented as a function indicating the suitability of phenotypes A set of individuals with their associated statistics (fitness average, Hamming distance, ...) Policy for selecting one individual from the population (selection of the fittest, ...) Operation that merges the genotypes of two selected parents to yield two new children Operation that spontaneously changes one or more alleles of the genotype

The algorithm operates on a population of strings or, in general, structures of arbitrary complexity representing tentative solutions. In the textbook versions of GAs, every string is called an individual and it is composed of one or more chromosomes and a fitness value. Normally, an individual contains just one chromosome (i.e. haploid individuals, although some diploid and n-ploid concepts and applications exist, see [26]) that represents the set of parameters called the genes. Every gene is in turn encoded (usually) in binary (or Gray) by using a given number of alleles (0,1) (see Figure 3). The fitness function behaves as the environment within which the quality of the decoded version of the genotype (called the phenotype) is evaluated. The fitness function was used in the early applications of EAs to encapsulate the problem knowledge, while the rest of the algorithm was a general-purpose algorithm with standard operators performing a blind-search, only guided by the values returned by this function. However, this vision is somewhat old, and we now know that problem knowledge is in general a necessity to provide efficient GAs (see the No Free Lunch Theorem [74]). In fact, GAs are considered as a family of parameterizable meta-heuristics that have to be tailored for every new application in order to have some chances of outperforming other search techniques.

-3-

Individual Chromosome

CHROMOSOME

Genes

Gene 8 Gene 7 Gene 6 Gene 5 Gene 4 Gene 3 Gene 2 Gene 1 Gene 0

Alelles Loci

FITNESS

1 1 0

1 0 1

0 0 1

0 1 0

1 1 1

1 0 0

0 1 1

0 0 0

1 0 1

2 1 0

2 1

2 1 0

2 1

2 1 0

2 1 0

2 1

2 1 0

2 1 0

0

0

0

Figure 3. Some details on the genotype. To illustrate how a canonical GA works we must remember that the population of individuals can be ranked according to the fitness values. Then, probabilistic selection of the fittest can be applied to select two parents and cross them to yield two new children. These children have the mixed and also mutated contents inherited from their parent chromosomes. These operations are repeated until a new population has been built up. The new population needs to be evaluated, and then the process starts again. Crossover and mutation are applied according to a given probability, and not deterministically. String# 1 2 3 4 Total

String 01101 11000 01000 10011

Fitness 169 576 64 361 1170

1. Roulette Wheel Selection (RW) PSi =

2. Single Point Crossover (SPX) pc ∈ [0.6 .. 1.0]

fi

parents 01|101 (169) 11|000 (576)

n

∑ fj

j=1

10011 01000

31%

% of the Total 14.4 49.2 5.5 30.9 100.0

01101

3. Mutation

14%

5%

offspring 01000 (64) 11101 (841)

pm ∈ [0.001 .. 0.1] st

Mutation of the 1 allele

50%

11000

0 1 0 0 0

1 1 0 0 0

4

4

3

2

1

0

fitness=64

Ö

3

2

1

0

fitness=576

Figure 4. An example of the computations that a GA performs to maximize f(x)=x2. The parameter x is encoded as a binary string of five bits. The population size is four strings. See in Figure 4 some basic implementations of these operators (roulette wheel selection, single point crossover, and bit-flip mutation [26]). In roulette wheel selection pairs of strings are selected attending to their fitness in relation to the mean fitness of the population. Even very bad strings have a non-zero probability of being selected for reproduction (although this rarely occurs). The crossover makes hyper-plane recombination in the search space by merging string slices of the two selected parents. Finally, the mutation randomly flips (with a low probability) every bit value in order to insert fresh values in the population, allowing jumps in the problem space.

-4-

3. PARALLEL GENETIC ALGORITHMS If we mimic natural evolution we would not operate on a single population in which a given individual has the potential to mate with any other partner in the entire population (panmixia). Instead, species would tend to reproduce within subgroups or within neighborhoods. A large population distributed among a number of semi-isolated breeding groups is known as polytypic. A PGA introduces the concept of interconnected demes. The local selection and reproduction rules allow the species to evolve locally, and diversity is enhanced by migrations of strings among demes. In the Subsection 3.1 we present some generalities on the EA branch dedicated to PGAs. Next, in Subsection 3.2, we detail the mechanics of a parallel genetic algorithm more formally.

3.1. Introduction to Parallel Genetic Algorithms Let us begin by explaining why one should bother using a parallel GA. We can summarize the advantages of using a PGA in Table II. A PGA has the same advantages as a serial GA, consisting in using representations of the problem parameters (and not the parameters themselves), robustness, easy customization for a new problem, and multiple-solution capabilities. These are the characteristics that led GAs and other EAs to be worth of study and use. In addition, a PGA is usually faster, less prone to finding only sub-optimal solutions, and able of cooperating with other search techniques in parallel. TABLE II. ADVANTAGES OF USING A PGA Advantages of using a Parallel Genetic Algorithm

n Works on a coding of the problem (least restrictive) o Basically independent of the problem (robustness) p Can yield alternative solutions to the problem q Parallel search from multiple points in the space

r Easy parallelization as islands or neighborhoods s Better search, even if no parallel hardware is used t Higher efficiency and efficacy than sequential GAs u Easy cooperation with other search procedures

For an overview of the applications of parallel genetic algorithms (PGAs) see [3], [4], [7], [66]. Also, there is a lot of evidence of the higher efficacy and efficiency of PGAs over traditional sequential GAs (for example [1], [7], [16], [55], [59]). PGAs are a class of guided random evolutionary algorithms (see a taxonomy of search methods in Figure 5). If we take a deeper look at them we can distinguish among 4 different types of parallelization [16]. Types 1 and 2 proceed in the same way as a sequential GA, but in a faster manner. This is achieved by either profiting from a code parallelizer embedded in the compiler, or else by the explicit parallelization (master-slave global parallelization) of the genetic operators and/or evaluations. However, only for problems with a time-consuming function evaluation do they represent a viable choice; otherwise the communication overhead is higher than the benefits of their parallel execution. Many different models have been proposed for the rest of PGAs (types 3 and 4). However, all these existing models can fit into two more general classes depending on their grain of parallelism, called coarse [68], [73] or fine grain [21], [32], [46] parallel GAs (cgpGAs and fgpGAs). This classification relies on the computation/communication ratio. If this ratio is high we call the PGA a coarse grain algorithm, and if low then we call it a fine grain parallel GA. However, as we will point out in the next section and have suggested in the introduction, some other criteria exist to distinguish them. What we really have is a continuum of model types between coarse and fine grain models of parallel GAs, all of them evolving separate populations. The implementation of these separate evolution models differs from each other, giving birth to numerous variants, some (many) of them difficult to classify.

-5-

Coarse grain PGAs are also known as distributed or island GAs (dGAs), and fine grain PGAs are known as cellular (cGAs), diffusion or massively-parallel GAs. The early models of cgpGAs were conceived of as running on MIMD platforms, while fgpGAs were developed to exploit the SIMD parallelism. S E A R C H T E C H N IQ U E S

C A LC U LU S B A SE D

D IR E C T

F ib o n a c c i

N ew to n

E N U M E R A T IV E S

RANDOM

G U ID E D

IN D IR E C T

G reed y

Tabu S earc h

L as V egas

S im u la t ed A n n e a lin g

E V O L U T IO N A R Y A L G O R IT H M S

E V O L U T IO N S T R A T E G IE S

E V O L U T IO N A R Y P R O G R A M M IN G

1

2

3

O n e p o p u la t io n , P a r a lle l e v a ls . + C ro s s . + M u t a t .

B a c k tr a c k i n g

K oh onen M aps

M u lt ila y e r P e r c ep tr o n s

S E Q U E N T IA L G A s

4 COARSE G R A IN PGAs

HOM OGENEOUS

HARDWARE PLA TFO R M

B ra n c h & B ound

G E N E T IC A L G O R IT H M S

PA R A LLE L G A s

A u to m a ti c P a r a lle li sm ( c o m p ile r)

D y n a m ic P ro g r a m m in g

N O N G U ID E D

NEURAL NETW ORKS H o p fi eld

G E N E T IC P R O G R A M M IN G

G U ID E D

N O N G U ID E D

G e n e ra ti o n a l

S te a d y - S ta te

M e s sy

F IN E G R A IN PGAs

HETEROGENEOUS

SO FTW AR E (S E A R C H )

HARDWARE PLA TFO R M

SO FTW AR E (S E A R C H )

Figure 5. Taxonomy of search techniques. A typical coarse grain parallel GA is a ring (hypercube or other disposition) of sub-populations running in parallel with sparse migrations of copies or of individuals among them [68]. On the other hand, the most popular fine grain parallel GA is a toroidal grid of individuals, each one interacting only with its neighborhood [46]. A PGA can run on a network of computers or in massively parallel computers, with independence of its granularity. This provokes a further classification depending on the homogeneity of the hardware: do sub-algorithms run on similar computers?. On the other hand, the sub-populations belonging to a cgpGA (local strings in a fgpGA) can evolve by applying the same techniques or by using different kinds of coding, operators, parameters, etc. The latter is the reason for our distinction about homogeneity at the software level (see the bottom part of Figure 5).

3.2. Algorithmic Description of a PGA In this section we formalize and visualize the different types of PGAs from a unifying point of view. This is aimed at helping future research in the field: comparisons, knowledge exchange, proposal of new models, etc. The outline of a general PGA is shown in Algorithm 1. As a stochastic technique, we can distinguish three major steps, namely initial sampling, optimization, and checking the stopping criterion. Therefore, it begins (t=0) by randomly creating a population P(t=0) of µ structures, each one encoding the p problem variables on some alphabet. Each structure is usually a vector over IB={0,1} (I= IB p⋅lx) or IR (I= IR p ). Consequently, each problem variable is encoded in lx bits or in a floating-point number. However, as mentioned before, other non-string representations are possible.

-6-

ALGORITHM 1: PARALLEL GENETIC ALGORITHM t := 0; initialize:

  P(0) := {a1 (0),..., a µ (0)}∈ I µ ;   P(0) : {Φ (a1 (0) ),...,Φ (a µ (0) )};

evaluate:

while ι (P(t ) ) ≠ true do select: P ′(t ) := s Θ s (P(t ) ) ;

// Reproductive plan

P ′′(t ) := ⊗ Θ c (P ′(t ) ) ;

recombine:

P ′′′(t ) := mΘ m (P ′′(t ) ) ;   P ′′′(t ) : {Φ (a1′′′(0) ),...,Φ (a λ′′′(0) )}; P(t + 1) := rΘ r (P ′′′(t ) ∪ Q ) ;

mutate: evaluate: replace:

t := t +1 ; end while To illustrate the very different genotypes that a GA can evolve we show in Figure 6 four examples of complex data structures used in diverse applications. In Figure 6a, a binary string represents a mapping from processes (genes) to processors (gene values) [4]. In Figure 6b, every individual encodes a tree of symbols representing the rules of a fuzzy logic controller [5]. Figure 6c describes how a binary string can be interpreted as an integer sequence; each integer value represents a fired transition in the finite state machine of a communication protocol [6]. Finally, in Figure 6d we plot an individual containing real-valued genes encoding the weights of a neural network in order to train it with a GA [3]. RLIST IF

Process 1 P0 10

P1 01

P2 11

Pn 00

....................

AND

IS Type I

IS

Processor 1 Processor 2

EL

IS

PL

FOR

Type II Type III

Processor 0

POS

NL

VEL

NL

Type IV

IF pos IS NL AND vel IS NL THEN for IS PL

(b)

(a)

GENETIC STRING

String

(a-n)...(m-n)(a-o)...(m-o)(a-p)..(m-p)(n-q)(o-q)(p-q)...(n-z)(o-z)(p-z)

[10, 35, 204, 78, 27, 106] Interpretation Pointer

Input Layer

FSM1 Actual State

i w

a

c

b

...

m

FSM2 Fires Two active transitions

j

n

Hidden Layer

Actual State

Output Layer

u

(c)

q

o

r

p

s

...

z

(d)

Figure 6. Complex data structures -I- evolved by a PGA. In this figure every individual encodes: (a) an assignment of processes to processors, (b) a rule base for a fuzzy logic controller, (c) a firing sequence for a finite state machine, and (d) a real-valued vector containing the weights of a neural network.

-7-

An evaluation function Φ is needed each time a new structure is generated in the algorithm. This evaluation is used to associate a real value to the (decoded) structure indicating its quality as a solution to the problem. All the mentioned structures encode tentative solutions to complex systems in a single genetic individual. This individual is used to simulate this complex system every time an evaluation is requested by the algorithm. Consequently, it can be inferred that considerable time is spent when complex and real-life applications are being tackled with GAs, thus supporting our claims about the need of using parallel GAs as more efficient search methods. Afterwards, the GA iteratively applies some set of variation operators on some selected structures from the current population. The goal is to create a new pool of λ tentative solutions and evaluate them to yield P(t+1) from P(t). This generates a sequence of populations P(0), P(1), P(2), ... with increasingly fitter structures. The stopping criterion ι is to fulfill some condition like reaching a given number of function evaluations, finding an optimum (if known), or detecting stagnation in the algorithm after a given number of generations. See [26], [36] and [49] for the introductory background. The selection sΘs uses the relationship among the fitness of the structures to create a mating pool. Some parameters Θs might be required depending on the kind of selection [13]. Typical variation operators are crossover (⊗ binary operator) and mutation (m, unary operator). Crossover recombines two parents by exchanging string slices to yield two new offspring, while mutation randomly alters the contents of these new structures. They both are stochastic operators whose behavior is governed by a set of parameters like a probability of application: Θc={pc} -high- and Θm={pm} -low-. Finally, each iteration ends by selecting the µ new individuals that will comprise the new population. For this purpose, the temporary pool P’’’(t) plus a set Q are considered. Q might be empty (Q=∅) or contain part of all of the old population Q=P(t). This step applies a replacement policy r that uses the temporary pool (and optionally the old pool) to compute the new population of µ individuals. The best structure in one population usually deterministically survives in the next generation, giving rise to the so-called elitist evolution (or R-elitism if R>1 -more than one string survives-). The best structure ever found is used as the PGA solution. Many sequential variants exist, but only two of them are especially popular. The first one is the generational GA -genGA-, where a whole new population is created from the old one (λ=µ) to replace it (Q=∅). The second variant is the steady-state GA -ssGA- in which only a few structures are generated in each iteration (λ=1 or 2) and they are inserted in the current population (Q=P(t)) [67] -see Figure 7-. At present, many skilled practitioners use genGAs in which λ

Meaning of the Symbol

XpertRule GenAsys

PC/BEAGLE

OMEGA

EVOLVER 2.0

SGA-Cube

SGA

PARAGENESIS

HSDGA

GENESIS 5.0 - GENEsYs 1.0

GDGA

GAucsd 1.2 / 1.4

GAMAS

GALOPPS 3.1

GAGA

ECO-GA

DGENESIS 1.0

CoPDEB

ASPARAGOS

-17-

SUGAL 2.0

PGAPack

PGA 2.5

OOGA

LibGA

GENITOR I - II

GAlib

ESCAPADE 1.2

EM 2.1

Algorithm Oriented Algorithm Specific Algorithm Libraries

GA Workbench

TOLKIEN

Splicer 1.0

RPL2

PeGAsuS

GAME

GAGS

EnGENEer

Tool Kits Educational General Purpose

TABLE VIII. CLASSIFICATION OF THE GENETIC SYSTEMS

The algorithm performs operations on every string by interactions with only its neighboring strings Generational: The basic algorithmic step is a full generation of individuals Steady-State: the basic algorithmic step is the computation of a very low number of individuals (usually one) GAP: The algorithm works and replaces only a given percentage of the whole population of individuals Evolution Strategy The individuals are sorted according to increasing fitness and the selection uses the ‘position’ in the rank (and not the fitness itself) Parallel version is not available yet or parallelism is a minor characteristic of the execution of the algorithm The algorithm is able to work either in sequential and in parallel http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/genetic/ga/systems pub/software/Evolution_Machine/em_tc.exe

Application Oriented

Local Gen. SS Percentage ES Rank par SEQ/PAR *

Symbol

TABLE VII. MEANING OF THE SYMBOLS

6. TECHNICAL ISSUES IN PARALLEL DISTRIBUTED GAs In this section we present the most important advances in the procedures governing the evolution of a parallel distributed GA. Most of these are related to the operators being applied, and this is the subject of the first Subsection. The rest are related to the migration policy and the heterogeneity of the algorithm (second and third Subsections).

6.1. Basic Algorithmic Components In this section we explain the basic techniques leading the evolution in the sub-algorithms of a parallel GA (particularly in the islands of a distributed GA). These techniques include the mode of evolution, the selection and replacement techniques, and the variation operators, namely crossover and mutation. 6.1.1. The Evolution Mode As regards the kind of evolution the dGA performs, there are basically two important models: the generational [26] and the steady-state [67] models. In fact they are the two extreme ends of the granularity of the evolution step (as shown in Figure 7). The class of messy-GAs [28] is an example of a very different but interesting kind of search that have yet received a lower international interest. Traditionally, each island in the dGA creates a new population of individuals from the old one by applying genetic operators such as selection, crossover or mutation. However, this basic generational GA is slow and loses diversity quickly. The offspring is not available for use until the new generation. Skilled practitioners do not usually utilize this kind of models; instead, they replace a percentage of the population. This has leaded to several extensions of this model, and to many intermediate selection methods. Steady-state evolution creates in every step just a single new string by applying genetic operations, and inserts it back according to a given replacement policy (for example only if it is better than the worst existing string or randomly). This kind of GA behaves very well in terms of efficacy, and very fast evolution (up to 10 times faster than a generational GA) in many real applications [20], [39], [41], [72]. Parents and children coexist in the same population and the algorithm can use the new offspring for further operations immediately after their insertion. Messy GAs have very different genotypes that also influence the kind of applied genetic operations highly. They have also proven to be a fast class of algorithms (see Figure 5 again). In general, the evolution models are different in the number of offspring λ they create from the µ individuals present in the population, and how the former replace the latter ones [11]. Nothing prevents of using nodal GAs in the islands of a dGA that perform arbitrary evolution modes, such as a structuredpopulation GA, like suggested in [57]. 6.1.2. The Selection Operator The selection mechanism of a dGA plays an important role. It drives the search towards better individuals promoting convergence. This operation implements a trade-off between high convergence velocity and high probability of finding a global optimum in complex problems. In this section we offer a brief resume of the more important selection schemes used in evolutionary algorithms. In the & following table µ is the number of strings in one population and ( ai ( t )) is a string at evolution step t.

-18-

The proportional selection method directly uses the fitness to select individuals. The ranked mechanisms use the position of the string in a sorted population (from 1 to µ) with increasing values of fitness (we suppose a maximization problem without any loss of generality). This is thought to help the search when fitness values are very similar (for example at the end of the evolution). We classify a selection scheme in terms of several criteria (Table IX). All these criteria are discussed by showing the probability of selection of any individual. In any case the sum of probabilities is always 1. TABLE IX. SELECTION SCHEMES Selection Scheme

Formalization &

Linear Ranking

&

p s (a i (t ) ) = Φ (a i (t ) )

Proportional &

p s ( a i (t )) =

1 µ

Comments

µ

∑Φ (a

&

j =1

j

(t ) )

[36] Called Roulette Wheel

 i −1   ⋅ η máx − (η máx − η mín ) ⋅ µ − 1  

(

Whitley’s Linear Ranking

µ Índice( χ , b) = ⋅ b − b 2 − 4 ⋅ (b − 1)⋅ χ 2 ⋅ (b − 1)

(µ,λ)-Uniform Ranking

1 λ 1 ≤ i ≤ λ  & p s (a i (t ) ) =   0 λ 0

p s (ai (t ) ) = ci

p s (ai (t )) = 0

Left Extinctive ⇔ ∀t ≥ 0, ∃l ∈ {1,..., µ − 1} &

i ≤ l ⇒ p s (ai (t ) ) = 0

k-Elitist

&

p s (ai (t ) ) = ci

Right Extinctive ⇔ ∀t ≥ 0, ∃l ∈ {2,..., µ} &

i ≥ l ⇒ p s (ai (t ) ) = 0 Pure

Shall the best k parents undergo selection with their offspring?

⇔ ∃k ∈ {1,..., µ}, ∀t ≥ 0, ∀i ∈ {1,..., k }



Shall a whole population of µ individuals be generated?

Generational

Steady-State

&

&

f (ai (t ) ) ≥ f (ai (t − 1) )

Any node in a dGA or in a cGA is thought to apply one of these selection algorithms on its own sub-population. Other interesting operators like tournament or even improved implementations of fitness proportional selection like stochastic universal sampling can be found elsewhere ([13]).

-19-

6.1.3. The Replacement Policy The replacement policy is used in each sub-algorithm of a PGA to replace some individuals in the present population with a new pool of individual(s). These new individuals may have been created in the local or in a remote sub-algorithm. Table XI shows the probabilities of replacement of several policies. TABLE XI. DIFFERENT POLICIES FOR THE REPLACEMENT OF STRINGS Replacement Scheme Inverse Proportional

Formalization &

µ

∑Φ (a (t ))

&

pr (ai (t ) ) = 1 − Φ (ai (t ) )

&

j

The inverse of the roulette wheel selection

j =1

&

p r (ai (t )) = c =

Uniform Random

Comments

1 µ

Worst

1 i = worst _ position   p r (a i (t ) ) =   0 i ≠ worst _ position 

Generational

p r ( a i ( t )) = 1

&

Any individual can be replaced according to the same probability (typical in steady-state) Always replace the worst string in a sorted population. A popular version replaces the worst string only if the new one is better Canonical generational GAs replace the whole old population with a new one

Just like the selection policy, the replacement admits different versions and hybridizations. Hence, we can define an elitist generational replacement, extinctive replacement, etc. 6.1.4. The Crossover Operator The crossover is one of the most studied operators in parallel and sequential GAs. Many variants have been defined. All of them can be included in one of the following classes: • Pure crossover operators: robust procedures that can be applied to many problems. • Hybrid crossover operators: mixing of a pure crossover operator and some other algorithm. • Problem dependent operators: these carry out very specialized operations on the strings, usually by including specific problem knowledge. The traditional crossover operates on two parents to yield two new offspring. However, there exist many versions which only compute one new string from these two parents. Also, it is normal in combinatorial optimization or in reordering problems (in which the strings are permutations) to use a safe crossover: the offspring of two correct strings are also correct. This is a need in some problems when not all the possible strings are allowable solutions, e.g. when managing constraints [49]. Often the constraints are dealt with in the fitness function (if a string does not match a given problem constraint its fitness will be penalized severely). However, some applications find it more efficient to force the crossover to work out only correct strings [5]. A third solution is to repair the incorrect strings. The most traditional crossover randomly defines a position in every parent string as the crossing point. Afterwards, the two parent strings exchange their slices located before and after these point. Multiple extensions of this single point crossover (SPX) are possible. They are known as N-point crossover operators [63]. A very interesting operator in this family is the two-point crossover (DPX). In DPX two points are stochastically defined and the two parents exchange the slices bounded by these two limits. A version we call DPX1 has been successfully used [6], [7] to yield only one child that contains the largest possible slice from the best (higher fitness) parent; the other offspring is never generated, thus representing a basic and inexpensive evolution step. See the following formalizations of the mentioned operators (G is I in the Algorithm 1 previously showed).

-20-

c Single Point Crossover (SPX) c

{ pc }

:GxG → GxG

τ ∈ [ 0,1]

α ∈ {1, . . . , l }

(& (

&

) ( ) (

if τ ≤ pc then c{ p } a = ( a1 , . . . , a l ) , b = ( b1 , . . . , bl ) = ( a1 , . . . , , aα , bα +1 , . . . , bl ) , ( b1 , . . . , , bα , aα +1 , . . . , a l ) c & & else c{ p } a = ( a1 , . . . , a l ) , b = ( b1 , . . . , bl ) = ( a1 , . . . , a l )( b1 , . . . , bl ) c

)

)

c Double Point Crossover 1-child (DPX1) c

{ pc } :GxG → G

&

( ) & & c ( a = ( a1 , . . . , a l ) , b = ( b1 , . . . , bl ) ): = ( a1 , . . . , , aα , bα +1 , . . . , bσ , aσ +1 , . . . , a l ) {p } & & c ( a = ( a1 , ..., a l ) , b = ( b1 , ..., bl ) ) = ( a1 , ..., a l ) {p }

τ ∈ [ 0,1]

α , σ ∈ {1, ..., l }, σ ≥ α

if τ ≤ p c

then

&

Φ ( a ) ≥ Φ b ∧ (σ − α ) < l 2

c

else

c

c Biased Uniform Crossover (UX(Pb)) c

if τ ≤ pc then

&

( )

&

τ ∈ [ 0,1] α i ∈ [ 0,1]

{ pc } :GxG → GxG

Φ (a) ≥ Φ b

ai  ′ ′ ′  c { pc } a , b = a , b , ai =  b  i

(

& &

) ((

&

&

αi sampled anew for every allele

 bi α i > Pb   ′ , bi =  a i α i ≤ Pb 

))

(&

usually Pb≥0.5

) (

&

else c{ p } a = ( a1 , . . . , a l ) , b = ( b1 , . . . , bl ) = ( a1 , . . . , a l )( b1 , . . . , bl ) c

)

α i > Pb   ∀i ∈ {1, . . . , l } α i ≤ Pb 

c Biased Arithmetic Crossover (AX(Pb)) c

{ pc }

if τ ≤ pc then else

c c

&

( )

&

τ ∈ [ 0,1]

:GxG → GxG

Φ (a) ≥ Φ b & &

&

usually Pb≥0.5

′ ′ ′ ′ { pc } ( a , b ) = ( ( a , b ) ) , ai = Pb ⋅ ai + (1 − Pb ) ⋅ bi , bi = Pb ⋅ bi + (1 − Pb ) ⋅ ai ∀i ∈ {1, . . . , l } &

& } ( a = ( a , . . . , a ) , b = ( b , . . . , b ) ) = ( ( a , . . . , a )( b , . . . , b ) ) &

{ pc

1

l

l

1

1

l

1

l

The uniform crossover (UX) is usually implemented by creating two offspring with every allele in the new offspring taken randomly from one parent (Pb=0.5). Here we present a generalized biased version in which the alleles of the best parent have a higher probability of appearing in the child. The arithmetic crossover (AX) has the same aspect but every child allele is a weighted new value of the two parental alleles. This is intended to be useful for floating point codes. These two operators (UX and AX) are independent of the length of the string. This characteristic is very useful in many real complex applications. See in Figure 12 a graphical interpretation of these crossover operators. In general, there exist typical operators of high efficacy depending on the field of application. Thus, for training neural networks we can use a traditional DPX or else a reduced surrogate operator [72]. For the traveling salesperson problem (TSP) better results can be obtained by using circuit crossovers such as Partially Matched Crossover (PMX), Cyclic Crossover (CX), Order Crossover (OX), etc. [49]. Also, the interesting and recent incorporation of fuzzy connectives to develop new classes of crossover operators is very promising, in particular for real representations (see [34] for more details).

-21-

Padre1 Parent1

Padre2 Parent2

SPX SPX

Descendiente Offspring

+ Padre1 Parent1

= Padre2 Parent2

DPX DPX

Descendiente Offspring

+ Padre1 Parent1

= Padre2 Parent2

UPX UX

Descendiente Offspring

+ Padre1 Parent1

= Padre2 Parent2

APX AX

Descendiente Offspring

+

=

Figure 12. The work of several crossover operators (only one child is shown). 6.1.5. The Mutation Operator The mutation operator is intended to introduce new genotypes into the genetic pool of strings. The goal is to maintain a good diversity that allows a continuous search towards a solution. This is needed to escape from local optima when the algorithm has got stuck in bad regions of exploration [64]. It can help also in refining a sub-optimal solution. In a dGA the migration of individuals from a neighbor island also extends the exploration in the distributed populations (an effect similar to that of mutation). c Bit-Flip Mutation m

{ pm }

:G → G

{ p m } ( s1

m

) (

, ..., sl = s1′ ,..., sl′

)

∀j ∈ {1,..., l } s′j =

 s j    1 − s j

   pm 

α i > pm αi ≤

α j ∈ [ 0,1]

The traditional mutation works on binary strings by probabilistically changing every position (allele) to its complementary value. In addition, many possible versions exist. For example, for floatingpoint real representations the mutation could add/subtract some random value to the allele. Frequently, the new gene value is determined after a fixed probability density function (PDF) drawn from the evolution strategies field, in which a Gaussian formula gives the additive new value of every real-valued gene. The standard deviation σj might be different for every gene, and could also be evolved. c Mutation for Real-Coded Strings m

{ pm }

:G → G

α i > p m  sj  α j ∈ [ 0,1]  s + σ ⋅ N (0,1) α ≤ p   j j i m   

m{pm } (s1 ,..., s l ) = (s1′ ,..., s l′ ) ∀j ∈ {1,..., l} s ′j = 

When the mean is zero the standard deviation offers the control on the mutation process. The use of zero-mean Gaussian mutations generates offspring that are on average no different from their parents, and increasingly less likely to be increasingly different from their parents [10].

-22-

An interesting modification of any type of mutation consists in varying its application probability throughout the evolution. Hence, we could increase the mutation probability very slightly in each iteration. This is appropriate since, at the beginning, the genotypes are different enough to sustain exploration, but, by the end, they become very similar. This dynamic probability can follow an a priori given linear or exponential growth or be computed (for example) as the inverse of the Hamming distance of the strings in the population. See [39] for more details. This dynamic variant is also possible for crossover or for other hybrid operators we would want to apply (if guided by a probability of application).

6.2. Migration Migration is the operator that guides the exchange of individuals among demes in a dGA. In relation to migration many aspects have to be fine-tuned to define the kind of search we are dealing with. In this section we want to outline the most accepted techniques and highlight some open questions. We discuss the frequency of migrations, how many migrants have to migrate, how to select and replace them in the target island, some considerations about the topology of islands, and the heterogeneity of the system. 6.2.1. Migration Gap Since a dGA usually makes sparse exchanges of individuals among the sub-populations we must define the migration gap, i. e., the number of steps in every sub-population between two successive exchanges (steps of isolated evolution). This can be made in every sub-population periodically or else by using a given probability of migration PM to decide in every step whether migration will take place or not. A different approach can be found for example in [52] in which the authors explore the sigma-exchange algorithm consisting in only making migrations when the standard fitness deviation is small enough to make sense of the exchange of strings. Although this criterion can reduce the number of exchanges, it relies on the fitness and not on the genotypes of the parallel islands (this could be a disadvantage). It is very usual for a parallel dGA to be synchronous in that the phases of migration and reception of external migrants are embedded in the same portion of the algorithm. However, synchronous migrations are known to be slow for some problems [52], [70]. In the asynchronous versions the reception of individuals are scheduled to occur at any time during a run of every island. This means sending migrants whenever it is needed, and also accepting migrants whenever they arrive. This last asynchronous parallel dGA can perform very efficiently [32], [52]. Besides this, its behavior and theoretical study is similar to its synchronous counterpart. However, if the sub-algorithms run in very different processors, the exchanged individuals can be in very different stages of evolution. Thus the well-known non-effect problem (the incoming migrant is unsuitable in its new population) or the super-individual problem (the incoming migrant is much better than the strings in the population receiving it) are very likely to appear. 6.2.2. Migration Rate The migration rate is the parameter determining the number of individuals that undergo migration in every exchange. This value can be expressed as a percentage of the population or else as an absolute value. In any case, it is not clear which is the best value for the migration rate. It seems to be clear that a low percentage should be used (from 1% to10% of the population size) but, although many studies have been conducted, no clear conclusions can be drawn. In fact it seems that, for some problems, sending 1 individual is better than sending 5 individuals, and vice-versa for other problems [47].

-23-

We think this is due to the close correlation existing between this value and the migration gap and topology. However, every topology has its own characteristics in terms of the velocity in spreading one individual into the whole set of sub-algorithms, thus interacting with the migration rate in a problem-dependent (or PGA model-dependent) manner. See [14], [47], [68] for results in this sense. 6.2.3. Selection and Replacement in the Migration Procedure It is very common in parallel dGAs that the same selection/replacement operators are used for dealing with migrants. Hence, all the presented models in sections 6.1.2 and 6.1.3 are useful here. Two alternative selection procedures for the migrants are (1) sending the best individual or (2) sending a random one. If you have no a priori knowledge of the problem under consideration you might decide to migrate a random individual. This is useful since it is the safest criterion for a large range of migration gaps (that you may also be trying to set correctly). If every sub-algorithm is sending the best individual then the migration gap needs to be considerably larger in order to avoid the premature convergence of the whole population (genotypic diversity disappears). 6.2.4. Topology There exist many works trying to decide the best topology for a parallel dGA [1], [31], [44], [47]. It seems that, for most problems, the ring and hyper-cube are two of the best topologies. Full-connected and centralized topologies have problems in their parallelization and scalability due to the tight connectivity. The ring topology is easy to implement on very different hardware platforms (cluster of workstations, multi-computers, ...), and its use is very extended. It is very usual for the topologies to be unidirectional. Hierarchical topologies such as trees of sub-algorithms have been also successfully applied [70]. A hierarchical topology is a natural way of carrying out the search at different levels. For example, in every level you can use a GA with a different kind of genotype and then get a dGA that first roughly determines the promising zones (leaves) and afterwards it exploits more accurate solutions inside these zones (e.g. [56]). The traditional nomenclature divides parallel dGAs into stepping-stone and island models, depending on whether individuals can freely migrate to any sub-population or if they are restricted to migrating to geographically nearby islands, respectively. Most recent papers assume to work with a given predefined topology.

6.3. Heterogeneity The homo-hetero/geneity of a distributed system is usually understood as a term referring to the hardware. This is also correct for a parallel dGA since it runs in several machines. However, we have an additional level for possible heterogeneity as regards to the kind of search the islands are making (Figure 5). We discuss this concept in this paper because of its potential benefits. This last represents an open research line: in which situations do a heterogeneous dGA outperform a homogeneous one?. The d sub-algorithms can be performing the same kind of search (same genotypes, operators, ...) on different sets of randomly generated individuals, or else the sub-algorithms can be using different sets of operators, parameters or genotypes. These last heterogeneous systems can have some advantages on homogeneous algorithms since they can be explicitly tuned to carry out exploration and exploitation (a well-known trade-off decision in evolutionary algorithms) depending on the problem [26].

-24-

EXPLORATION PLANE

E1

+

-

e1

E2

GA1 Pc Pm↑↑

e2 -

+

GA2 Pc Pm↑

CoPDEB E4

E3 Pc

e4

e3

GDGA

GA4

Good Pc, Pm GA3

eXPLOITATION PLANE

Figure 13. Two recent dGAs: GDGA (left) and CoPDEB (right). The Gradually Distributed GA (GDGA) [34] creates two planes of search with exploitation and exploration capabilities embedded in several fuzzy crossover operators (on real codes). The backward and forward migrations exchange individuals between these two planes of the hypercube-3. This is a synchronous model based on generational evolution. The Co-operating Populations with Different Evolution Behavior (CoPDEB) [2], on the other hand, applies traditional operators but it changes the probabilities of crossover and mutation in every sub-population in order to obtain different GAs, also with different exploration/exploitation properties. Besides this, local hill-climbing is included in islands. These algorithms represent two different ways of achieving heterogeneity. A third way is using a set of algorithms, some of them evolutionary and some other non-evolutionary methods, to cooperate/compete in solving the same problem and exchanging information in a distributed fashion.

7. IMPLEMENTATION ISSUES Among all the languages for developing PGAs, C is the most popular. However, implementations with C++ are now growing in number due to the advantages in software reuse, security, and extensibility. Also, because of its large capability of structured parameterization, an object oriented (OO) language has advantages in composing new prototypes. On the other hand, there exist many PGAs developed for concrete machine architectures that use embedded languages (usually versions of C). Using object orientation is directly useful in developing classes for the data structures and operations contained in a parallel or sequential GA. Hence, implementing classes for genotype, population, operator pool, fitness manipulations, etc... is a natural way of coding evolutionary algorithms in general with the added advantages of any OO implementation. Communication among processes is normally achieved by using the BSD socket interface on UNIX systems, either directly or through the services of the well known Parallel Virtual Machine (PVM) [25]. Some MPI [43] and JAVA implementations are also becoming familiar. Finally, many systems simulate parallelism in a single process. This latter is useful only when the basic behavior is to be studied. However, for real-life and complex applications, a truly parallel dGA is needed in order to have lower computational times and using larger populations than with sequential GAs.

-25-

8. CONCLUDING REMARKS In this work we have presented the fundamental syntax and semantics of sequential genetic algorithms (GAs). The paper deals with very popular extensions of these algorithms known as parallel distributed GAs, in which many sub-algorithms run in parallel with sparse migrations of strings. The robustness and advantages of sequential GAs are enhanced when a PGA is used. The drawback is the more complex analysis and design, and also the need of some kind of parallel machine to run it. A structured and extensive overview on the more important and up-to-date PGA systems is discussed. In it, much of the existing software and criteria for their classification is used. In addition, we present in the paper useful technical information about PGAs relating operators, structured-population paradigms, and parameters guiding the parallel search. We have included a brief theoretical foundation of a distributed GA to make the paper relatively self-contained. In all the presentation not only a survey of existing problems is outlined, but also possible variants apart from the basic operations and future trends are discussed. In particular, we have offered a location of PGAs in the taxonomy of search techniques, a nomenclature revision, algorithmic descriptions of techniques, future trends, a classification of a large portion of the existing software, open questions relating generational versus steady-state evolution modes and heterogeneous versus homogeneous parallel algorithms, and many other minor details and major concepts relating parallel GAs in general. Our main interest has been in parallel distributed GAs, since the impact of the research in this kind of algorithms is a priori larger than for other kinds of parallel genetic algorithms. We are especially concerned with offering useful and rigorous material that could help new and expert practitioners. Although our overview is obviously not complete, it represents a good starting point to conduct future research in this domain or to make new applications by using parallel distributed GAs.

ACKNOWLEDGEMENTS The authors want to thanks the anonymous reviewers whose comments and discussions helped to improve the contents of this article considerably.

-26-

References 1. P. Adamidis. “Review of Parallel Genetic Algorithms Bibliography”. Internal T.R., Aristotle University of Thessaloniki, November (http://www.control,ee.auth.gr/~panos/papers/pga_review.ps.gz). 1994. 2. P. Adamidis, V. Petridis. “Co-operating Populations with Different Evolution Behavior”. Proceedings of the Second IEEE Conference on Evolutionary Computation, pp. 188-191. 1996. 3. E. Alba, J. F. Aldana, J. M. Troya. “Full Automatic ANN Design: A Genetic Approach”. In J. Mira, J. Cabestany, A. Prieto (eds.), IWANN'93. New Trends in Neural Computation. Lecture Notes in Computer Science 686, Springer-Verlag, pp. 399-404. 1993. 4. E. Alba, J. F. Aldana, J. M. Troya. “A Genetic Algorithm for Load Balancing in Parallel Query Evaluation for Deductive Relational Databases”. Procs. of the I. C. on ANNs and GAs, D.W. Pearson, N.C. Steele, R.F. Albrecht (eds.), Springer-Verlag, pp. 479-482. 1995. 5. E. Alba, C. Cotta, J. M. Troya. “Type-Constrained Genetic Programming for Rule-Base Definition in Fuzzy Logic Controllers”. Proceedings of the First Annual Conference on Genetic Programming, J. R. Koza, D. E. Goldberg, D. B. Fogel & R. L. Riolo (eds.), Stanford Univ., Cambridge, MA. The MIT Press, pp. 255-260. 1996. 6. E. Alba, J. M. Troya. “Genetic Algorithms for Protocol Validation”. Proceedings of the PPSN IV I.C., H. M. Voigt, W. Ebeling, I. Rechenberg & H. P. Schwefel (eds.), Berlin. Springer-Verlag, pp. 870-879. 1996. 7. E. Alba, C. Cotta. “Evolution of Complex Data Structures”. Informática y Automática, 30(3), pp. 42-60. September, 1997. 8. C. Alippi, P. Treleaven. “GAME: A Genetic Algorithms Manipulation Environment”. Internal Report Department of Computer Science, UCL. 1991. 9. J. Antonisse. “A New Interpretation of Schema Notion that Overturns the Binary Encoding Constraint”. Proceedings of the 3rd ICGA, J. D. Schaffer (ed.), Morgan Kaufmann, pp. 86-91. 1989. 10. T.Bäck, D. Fogel, Z. Michalewicz (eds.) Handbook of Evolutionary Computation. Oxford University Press. 1997. 11. T. Bäck, H. P. Schwefel. “An Overview of Evolutionary Algorithms for Parameter Optimization”. Evolutionary Computation, 1 (1), pp. 1-23, The MIT Press. 1993. 12. J. E. Baker. “Adaptive Selection Methods for Genetic Algorithms”. Proceedings of the First International Conference on Genetic Algorithms and Their Applications, J. J. Grefenstette (ed.), Lawrence Erlbaum Associates, Publishers, pp. 101-111. 1985. 13. J. E. Baker. “Reducing Bias and Inefficiency in the Selection Algorithm”. Proceedings of the Second International Conference on Genetic Algorithms, J. J. Grefenstette (ed.), Lawrence Erlbaum Associates, Publishers, pp. 14-21. 1987. 14. T. C. Belding. “The Distributed Genetic Algorithm Revisited”. Proceedings of the 6th International Conference on GAs, L. J. Eshelman (ed.), Morgan Kaufmann, pp. 122-129. 1995. 15. P. P. Bonissone. "Soft Computing: the Convergence of Emerging Reasoning Technologies". Journal of Research in Soft Computing, 1(1), pp. 6-18. 1997.

-27-

16. E. Cantú-Paz. “A Summary of Research on Parallel Genetic Algorithms”. R. 95007, July 1995. Also revised version, IlliGAL R. 97003. May 1997. 17. A. Chipperfield, P. Fleming. “Parallel Genetic Algorithms”. Parallel and Distributed Computing Handbook, A. Y. H. Zomaya (ed.), MacGraw-Hill, pp. 1118-1143. 1996. 18. A. L. Corcoran, R. L. Wainwright. “LibGA: A User-Friendly Workbench for Order-Based Genetic Algorithm Research”. Proceedings of the 1993 ACM/SIGAPP Symposium on Applied Computing, ACM Press. 1993. 19. F. Corno, P. Prinetto, M. Rebaudengo, M. Sonza-Reorda. “Exploiting Competing Subpopulations for Automatic Generation of Test Sequences for Digital Circuits”. Procs. of the PPSN IV I.C., H. M. Voigt, W. Ebeling, I. Rechenberg, H. P. Schwefel (eds.), Springer-Verlag, pp. 792-800. 1996. 20. C. Cotta, E. Alba, J. M. Troya. “Evolutionary Design of Fuzzy Logic Controllers”. IEEE Catalog N. 96CH35855, Proceedings of the ISISC’96 Conference, Dearborn, MI pp. 127-132. 1996. 21. Y. Davidor. “A Naturally Occurring Niche & Species Phenomenon: The Model and First Results”. Procs. of the 4th ICGA, R. K Belew, L. B. Booker (eds.), pp. 257-263. 1991. 22. L. Davis, J. J. Grefenstette. “Concerning GENESIS and OOGA”. Handbook of Genetic Algorithms, L. Davis (ed.), New York: Van Nostrand Reinhold, pp. 374-376. 1991. 23. J. A. Erickson, R. E. Smith, D. E. Goldberg. “SGA-Cube, A Simple Genetic Algorithm for nCUBE 2 Hypercube Parallel Computers”. TCGA Report No. 91005, The Univ. of Alabama. 1991. 24. D. B. Fogel (ed.). Evolutionary Computation. The Fossil Record (Selected Readings on the History of Evolutionary Algorithms). IEEE Press. 1998 25. A. Geist, A. Beguelin, J. Dongarra, W. Jiang, R. Manchek, V. Sunderam. PVM: Parallel Virtual Machine. A Users’ Guide and Tutorial for Networked Parallel Computing. The MIT Press. 1994. 26. D. E. Goldberg. Genetic Algorithms in Search, Optimization and Machine Learning. AddisonWesley. 1989. 27. D. E. Goldberg. “Sizing Populations for Serial and Parallel Genetic Algorithms”. Proceedings of the 3rd ICGA, J. D. Schaffer (ed.), Morgan Kaufmann, pp. 70-79. 1989. 28. D. E. Goldberg, K. Deb, B. Korb. “Don’t Worry, Be Messy”. Proceedings of the Fourth International Conference on Genetic Algorithms, R. K. Belew and L. B. Booker (eds.), Morgan Kaufmann, San Mateo, CA, pp. 24-30. 1991. 29. D. E. Goldberg, et al. “Critical Deme Size for Serial and Parallel Genetic Algorithms”. IlliGAL Report No. 95002. January 1995. 30. E. D. Goodman. An Introduction to GALOPPS v3.2. TR#96-07-01, GARAGe, I. S. Lab., Dpt. of C. S. and C. C. C. A. E. M., Michigan State University, East Lansing. 1996. 31. V. S. Gordon, D. Whitley. “Serial and Parallel Genetic Algorithms as Function Optimizers”. Procs. of the 5th ICGA, S. Forrest (ed.), Morgan Kaufmann, pp. 177-183. 1993. 32. M.Gorges-Schleuter. “ASPARAGOS An Asynchronous Parallel Genetic Optimisation Strategy”. Procs. of the 3rd ICGA, J. D. Schaffer (ed.), Morgan Kaufmann, pp. 422-427. 1989. 33. J. J. Grefenstette. “GENESIS: A System for Using Genetic Search Procedures”. Proceedings of the 1984 Conference on Intelligent Systems and Machines, pp. 161-165. 1984.

-28-

34. F. Herrera, M. Lozano. Gradual Distributed Real-Coded Genetic Algorithms. Technical Report #DECSAI-97-01-03. February 1997 (revised version 98). 35. F. Hoffmeister. “The User’s Guide to ESCAPADE 1.2 A Runtime Environment for Evolution Strategies”. Department of Computer Science, University of Dortmund, Germany. 1991. 36. J. H. Holland. Adaptation in Natural and Artificial Systems. Univ. of Michigan Press, Ann Arbor, MI. 1975. 37. M. Hughes. “Genetic Algorithm Workbench Documentation”, Cambridge Consultants Ltd. 1989. 38. A. Hunter. “Sugal Programming Manual v2.0”. T. R. in Univ. Sunderland, U.K.. July 1995. 39. B. A. Juslstrom. “What Have You Done for Me Lately? Adapting Operator Probabilities in a SteadyState Genetic Algorithm”. Proceedings of the 6th International Conference on Genetic Algorithms, L. J. Eshelman (ed.), Morgan Kaufmann, pp. 81-87. 1995. 40. J. R. Koza. Genetic Programming. The MIT Press. 1992. 41. T. Kuo, S. Y. Hwang. “A Genetic Algorithm with Disruptive Selection”. Proceedings of the 5th International Conference on GAs, S. Forrest (ed.), Morgan Kaufmann, pp. 65-69. 1993. 42. D. Levine. “A Parallel Genetic Algorithm fot the Set Partitioning Problem”. T. R. No. ANL-94/23, Argonne National Laboratory, Mathematics and Computer Science Division. 1994. 43. D. Levine. “Users Guide to the PGAPack Parallel Genetic Algorithm Library”. T. R. ANL-95/18, January 31. 1996. 44. S. Lin, W. F. Punch and E. D. Goodman. “Coarse-Grain Parallel Genetic Algorithms: Categorization and New Approach”. Parallel & Distributed Processing. October 1994. 45. M. Lozano. “Application of Fuzzy Logic Based Techniques for Improving the Behavior of GAs with Floating Point Encoding”. Ph.D. Th., Dpt. of C. S. and A.I., Univ. Granada. July 1996. 46. B. Manderick, P. Spiessens. “Fine-Grained Parallel Genetic Algorithms”. Procs. of the 3rd I. C. on Genetic Algorithms, J. D. Schaffer (ed.), Morgan Kaufmann, pp. 428- 433. 1989. 47. M. Mejía-Olvera, E. Cantú-Paz. “DGENESIS-Software for the Execution of Distributed Genetic Algorithms”. Proceedings of the XX Conferencia Latinoamericana de Informática, pp. 935-946, Monterrey, México. 1994. 48. J. J. Merelo, A. Prieto. GAGS, “A Flexible Object-Oriented Library for Evolutionary Computation”. Procs. of MALFO, D. Borrajo, P. Isasi (eds.), pp. 99-105. 1996. 49. Z. Michalewicz. Genetic Algorithms + Data Structures = Evolution Programs. Springer-Verlag. 1992. 50. H. Mühlenbein. “Evolution in Time and Space - The Parallel Genetic Algorithm”. Foundations of Genetic Algorithms, G. J. E. Rawlins (ed.), Morgan Kaufmann, pp. 316-337. 1991. 51. H. Mühlenbein, M. Schomisch, J. Born. “The Parallel Genetic Algorithm as Function Optimizer”. Parallel Computing, 17, pp. 619-632. September 1991. 52. M. Munetomo, Y. Takai, Y. Sato. “An Efficient Migration Scheme for Subpopulation-Based Asynchronously Parallel GAs”. HIER-IS-9301, Hokkaido University. July 1993.

-29-

53. T. Muntean, E. G. Talbi. “A Parallel Genetic Algorithm for Process-Processors Mapping”. Proceedings of the Second Symposium II. High Performance Computing, M. Durán, E. Dabaghi (eds.), pp. 71-82. Montpellier, France: F. Amsterdam, Amsterdam. 1991. 54. NASA - Johnson Space Center. “Splicer - A Genetic Tool for Search and Optimization”. Genetic Algorithm Digest, Vol 5, Issue 17. 1991. 55. C. C. Pettey, M. R. Leuze, J. Grefenstette. “A Parallel Genetic Algorithm”. Proceedings of the 2nd ICGA, J. Grefenstette (ed.), Lawrence Erlbraum Associates, pp. 155-161. 1987. 56. J. C. Potts, T. D. Giddens, S. B. Yadav. “The Development and Evaluation of an Improved Genetic Algorithm Based on Migration and Artificial Selection”. IEEE Transactions on Systems, Man, and Cybernetics, 24 (1), pp. 73-86. January 1994. 57. N. J. Radcliffe, P. D. Surry. “The Reproductive Plan Language RPL2: Motivation, Architecture and Applications”. Genetic Algorithms in Optimisation, Simulation and Modelling, J. Stender, E. Hillebrand, J. Kingdon (eds.), IOS Press. 1994 58. I. Rechenberg. Evolutionstrategie: Optimierung Technisher Systeme nach Prinzipien der Biologischen Evolution. Fromman-Holzboog Verlag, Sttutg. 1973. 59. J. L. Ribeiro Filho, C. Alippi, P. Treleaven. “Genetic Algorithm Programming Environments”. Parallel Genetic Algorithms: Theory & Applications, J. Stender (ed.), IOS Press. 1993. 60. G. Robbins. “EnGENEer - The Evolution of Solutions”. Proceedings of the 5th Annual Seminar on Neural Networks and Genetic Algorithms. 1992. 61. N. N. Schraudolp, J. J. Grefenstette. “A User’s Guide to GAUCSD 1.2”. T. R. Computer Science & Engineering Department, University of California, San Diego. 1991. 62. H. P. Schwefel. Numerical Optimization of Computer Models. Wiley, Chichester. 1981. 63. W. M. Spears, K. A. De Jong. “An Analysis of Multi-Point Crossover”. Foundations of Genetic Algorithms, G. J. E. Rawlins (ed.), Morgan Kaufmann, pp. 301-315. 1991. 64. W. M. Spears. “Crossover or Mutation?”. Proceedings of the Foundations of Genetic Algorithms Workshop, D. Whitley (ed.), Morgan Kaufmann, pp. 221-237. 1992. 65. P. Spiessens, B. Manderick. “A Massively Parallel Genetic Algorithm”. Proceedings of the 4th International Conference on Genetic Algorithms, R. K. Belew, L. B. Booker (eds.), Morgan Kaufmann, pp. 279-286. 1991. 66. J. Stender (ed.). Parallel Genetic Algorithms: Theory and Applications. IOS Press. 1993. 67. G. Syswerda. “A Study of Reproduction in Generational and Steady-State Genetic Algorithms”; Foundations of GAs, G. J. E. Rawlins (ed.), Morgan Kaufmann, pp. 94-101. 1991. 68. R. Tanese. “Distributed Genetic Algorithms”. Proceedings of the 3rd International Conference on Genetic Algorithms, J. D. Schaffer (ed.), Morgan Kaufmann, pp. 434-439. 1989. 69. H. M. Voigt, J. Born, J. Treptow. “The Evolution Machine Manual - V 2.1”. T. R. in the Institute for Informatics and Computing Techniques, Berlin. 1991. 70. H. M. Voigt, I. Santibáñez-Koref, J. Born. “Hierarchically Structured Distributed Genetic Algorithms”. Proceedings of the International Conference Parallel Problem Solving from Nature, 2, R. Männer, B. Manderick (eds.), North-Holland, Amsterdam, pp. 155-164. 1992.

-30-

71. M. Wall. “Overview of Matthew’s Genetic Algorithm Library”. http://lancet.mit.edu/ga. 1995. 72. D. Whitley. “The GENITOR Algorithm and Selection Pressure: Why Rank-Based Allocation of Reproductive Trials is Best”. Proceedings of the 3rd. International Conference on Genetic Algorithms, J. D. Schaffer (ed.), Morgan Kaufmann, pp. 116-121. 1989. 73. D. Whitley, T. Starkweather. “GENITOR II: a Distributed Genetic Algorithm”. J. Expt. Theor. Artif. Intelligence 2, pp. 189-214. 1990. 74. D. H. Wolpert, W. G. Macready. “No Free Lunch Theorems for Optimization”. IEEE Transactions on Evolutionary Computation 1(1), pp. 67-82. 1997.

-31-