crossing over genetic algorithms: the sugal generalised ga

Journal of Heuristics, 4: 179–192 (1998)c© 1998 Kluwer Academic Publishers

Crossing Over Genetic Algorithms:The Sugal Generalised GA

ANDREW HUNTERDepartment of Computing and Information Systems, University of Sunderland, Tyne and Wear, Englandemail: [email protected]

Abstract

Sugal is a major new public-domain software package designed to support experimentation with, and implemen-tation of, Genetic Algorithms. Sugal includes a generalised Genetic Algorithm, which supports the major popularversions of the GA as special cases. Sugal also has integrated support for various datatypes, including real num-bers, and features to make hybridisation simple. This paper discusses the Sugal GA, showing how recombiningthe features of the popular algorithms results in the creation of a number of useful hybrid algorithms.

Key Words: genetic algorithms, simulated annealing, software package

Introduction

Sugal is a major new Genetic Algorithms package. The principal design aims of Sugalinclude the following:

• To facilitate comparison of existing Genetic Algorithms and related paradigms within asingle software environment;

• To support user-extension and customisation of the algorithm.

The pursuit of these aims has led to a novel design which not only supports existingparadigms, but subsumes them in a generalised version of the Genetic Algorithm. Effec-tively, the paradigms studied have been crossed over! The result is that the Sugal GeneticAlgorithm provides an elegant framework for classifying and describing Genetic Algo-rithms, in addition to producing a whole class of curious hybrid algorithms.

This paper is not principally concerned with the Sugal package; the reader is referredto the source code and documentation (Hunter (1995)) for more details. Rather, this paperconcentrates on the Sugal Genetic Algorithm, and its relationship to the paradigms whichit subsumes. However, a few salient details about the package are described below.

The Sugal package is designed to make customisation and extension simple. This isachieved through a number of mechanisms: a generalised Genetic Algorithm, integratedsupport for various datatypes, and extendible control parameters and actions. The first twoof these are described in detail in the rest of this paper. The control parameter and actionmechanism allows the user to customise the Sugal Genetic Algorithm by adding procedureswhich perform specific parts of the algorithm. For example, it is possible to add new forms

180 HUNTER

of crossover, mutation, fitness normalisation, selection and replacement. Hybridisation withother search techniques (including domain-specific techniques) is achieved by integratingsuch methods, which typically act by optimising a single solution in some fashion, as specialforms of mutation.

The Sugal Genetic Algorithm has been defined in as general as fashion as possible, withthe various parts of the algorithm independently controllable; this has led to the production ofnumerous hybrid algorithms, as mentioned above. Notable among these is the combinationof Simulated Annealing with the Genetic Algorithm. Sugal also supports a wide rangeof datatypes, including bit-strings, signed and unsigned integers, floating point numbers,symbols and permutations, all within an integrated environment. Of particular importance isthe support for real-number valued strings, which are traditionally neglected in the GeneticAlgorithms community.

A review of the subsumed paradigms

Algorithms based on abstractions of Natural Selection have been around for a long time:Fogel’s Evolutionary Programming (Fogel (1966)) dates back to the 1960s. However, themajor contributor to the field was John Holland, whose Genetic Algorithm (Holland (1975))has had a far greater impact than the parallel work of Fogel andEvolutionstrategie(Schwefel(1981)). It was Holland who coined the term “Genetic Algorithm”. Authors in the fieldtend to coin terms which are various permutations of the words “Genetic”, “Evolutionary”,“Algorithm” and “Programming”. The use of these names can be extremely confusing(I know of at least two entirely distinct meanings for the term “Genetic Programming”, forexample), and consequently I adopt a simple strategy in referring to all these algorithmscollectively as Genetic Algorithms. This recognises Holland’s greater influence in the field,without implying that all such paradigms are derived from his work.

Holland’s version of the Genetic Algorithm is distinguished from others by its emphasison two features: the use of bitwise strings, and the use of crossover as the primary searchmechanism. This contrasts with the work of Fogel (1990) and Schwefel (1981) who useinteger or real number strings, with mutation as the primary search mechanism. A muchearlier population-based approach, scatter search (Glover (1977)), incorporates both realnumbers and integers and uses other forms of combination, in addition to heuristic searchtechniques (a variety of extensions to this technique are found in (Glover (1997)).

Holland’s GA can be summarised (in Sugal terminology) as follows. A population ofchromosomes is maintained; each chromosome is a string of bits. On each generation thealgorithm cycles through the following stages:

• Evaluation

• Selection

• Crossover

• Mutation

• Replacement

In the evaluation stage, each chromosome is assigned a fitness value. A new populationis then bred. Parents are randomly selected with a chance proportionate to their relative

CROSSING OVER GENETIC ALGORITHMS 181

fitness. Some parental chromosomes are cloned directly into the child population. In othercases pairs of parents are crossed over, and the resulting chromosomes are inserted intothe child population. Whether or not crossover is used depends on the crossover rate. Thechildren may then be subjected to mutation: some randomly chosen bits may be inverted(flipped)—the chance of this happening is governed by the mutation rate. Once the newpool has been generated, it replaces the entire existing pool.

There have been a number of extensions to the basic GA. Among the most importantinnovations areelitismandreplacement rates. Elitism (DeJong (1975)) is a simple modifi-cation, based on the observation that stochastic effects can cause the simple GA to lose thebest existing chromosome. On each generation a copy of the best chromosome is retainedunmodified. Variable replacement rates have been suggested to prevent over-rapid conver-gence; the algorithm replaces only a (randomly selected) proportion of the population oneach generation (often referred to as ageneration gap).

There are also a number of variants of the genetic operators—crossover and mutation—including multipoint crossover and reinitialisation (as opposed to inversion) mutation. Thereare also more complex operators suited to non-bitwise chromosomes, although these areencountered in extensions to Holland’s work rather than the original GA. Although Sugal hasextensive facilities to support such operators, the extension of the algorithm to include themis conceptually simple and is not discussed further in this paper, except to note the following:complex search techniques which act by altering a single chromosome can be integratedwith the Genetic Algorithm in the guise of special mutation operators, producing a wholerange of specialised hybrid algorithms. With a little more effort, Sugal can also be modifiedto support algorithms such as scatter search which produce chromosomes from more thantwo parents, or use selection strategies not based on random selection. Sugal is specificallydesigned to support such hybridisation and extension.

A problem which has exercised many GA researchers is that offitness normalisation.The fitness of chromosomes is used to guide the selection of parents during replacement,and plays a critical role in determining the behaviour of the algorithm. The evaluationprocedure supplied to the Genetic Algorithm may not have good properties; for example,all the fitness values may be far from zero and close together. The algorithm can suffer froma number of problems due to poor fitness values. In the early stages of the algorithm, a fewexceptional individuals may have far greater than average fitness values, and their childrenmay dominate the entire population in just a few generations, leading to the problem ofpremature convergence. In later generations, there may be hardly any difference in fitnessvalues, leading toweak selective pressure. The usual solution to this problem is to usesome process to normalise (adjust) the fitness before they are used in selection. Goldberg(1989) has suggested perhaps the most popular approach: on each generation, the fitnessare linearly scaled so that the fitness of the best member of the population is a fixed constanttimes the mean fitness.

A significantly different form of algorithm, called Genitor, was devised by Whitley(1989). Partly, Genitor was designed to overcome these same problems of fitness scaling.Genitor uses fitness rankings in selection (i.e., the best chromosome has rank 0, the next rank1, etc.) rather than raw fitness values. Whitley took this concept further in Genitor, devisingan algorithm which not only uses rank-basedselection, but also rank-basedreplacement. InGenitor, parents are selected for breeding with a probability related to their rank. Only one

182 HUNTER

child is generated on each generation (if crossover is used, then two parents are selected,and one of the offspring is randomly discarded). The child so-generated is inserted intothe population only if it has a better fitness than the lowest ranking existing member of thepopulation. Thus, Genitor differs from the traditional GA in a number of respects:

• the normalised fitness which is used in selection is a function of the rank.• only a single chromosome is replaced on each generation, and this replacement isrank-

based(i.e., the worst is replaced) andconditional(i.e., only happens if the child is betterthan an existing chromosome).

It is principally the fault-lines across the replacement options which produce the variousmodels supported by Sugal.

The Sugal genetic algorithm

The Sugal Genetic Algorithm was designed to act as a superset of possible Genetic Algo-rithms, with Holland’s GA and Genitor as particular examples. This is achieved by splittingup the various (apparently interrelated) aspects of the algorithms. The Sugal Genetic Algo-rithm has the following basic structure:

On each generation:

Generate candidates:

Select parents

Apply Genetic operators to create candidates

Evaluate candidates

Replacement:Match candidates against existing pool members

Replace if replacement condition is satisfied

Reevaluation

Normalisation

On each generation, the Sugal Genetic Algorithm generates a list of candidate chro-mosomes—these are child chromosomes which may (depending on the precise algorithm)displace members of the existing population (thepool). The entire candidate list is generatedbefore any replacement takes place. The candidate list length may vary in size from one (asin Genitor) to the pool size (as in Holland’s GA). Once the list has been generated, replace-ment occurs as follows: take each candidate in turn, locate (using areplacement-selectionmethod) an old chromosome which the candidate may replace, and perform replacement ifa replacement conditionis satisfied.

Sugal supports a number of selection algorithms, which actually choose parental chro-mosomes for reproduction. This includes Holland’s basic roulette selection scheme, themodified expected value roulette selection scheme (Goldberg (1989)), and a tournament-based model. Other models can easily be added. As a pre-processing stage, Sugal performsfitness normalisation. At this stage, the raw fitness values (which were assigned during


evaluation) are converted into corresponding normalised fitness. For computational conve-nience, normalised fitness sum to 1.0 over the entire pool. A wide range of algorithms aresupported to adjust fitness; amongst these is the assignment of normalised fitness valuesdetermined from the chromosome rankings, as in Genitor. Sugal differentiates rank-basedselection from rank-based replacement (both of which are used in Genitor), so that theymay be used independently. Sugal also supports various forms of linear scaling of fitness,and all techniques have versions both to minimise and to maximise the raw fitness value.

Sugal also allows any proportion of the pool, from one individual to the entire pool, tobe replaced on each generation. Genitor is supported as a special case of one version of thealgorithm, where the replacement rate is set to a single individual.

Replacement selection

Sugal supports a number of schemes for choosing which members of the pool should beconsidered for replacement. In Sugal, each candidate is matched against a member of thepool, which it attempts to displace. A number of orthogonal issues have to be consideredhere. Looking at the subsumed paradigms, we see that in Holland’s basic GA, the entirepool is replaced. If a generation gap is being used, then the members of the pool to bereplaced are selected randomly, with a uniform chance of selection. To introduce elitism,we simply ensure that the replacement rate is always less than the entire pool, and refuseto mark the best member of the pool for replacement. Thus, in Holland’s GA replacementis unconditionalanduniform(with only a slight tweak to support elitism).

In contrast, Genitor’s replacement-selection algorithm isconditionalandrank-based. Italso immediately needs to be extended, since it supports a replacement rate of only oneindividual per generation. The extension of Genitor to multiple candidates per generationimmediately raises an issue. If we generateN candidates at once, and wish to consider themfor rank-based conditionalreplacement, which of theP existing chromosomes should wecompare them with? We could either take each candidate in turn, conditionally inserting itinto the pool if it is better than the worst existing chromosome, or we could pair off theNcandidates against theN worst members of the pool and perform the conditional insertionin parallel. We will call these optionsincrementalanddistinctreplacement. In incrementalreplacement, candidates are inserted into the pool one at a time, and once inserted maythemselves face replacement by other candidates on the same generation. In distinct re-placement, candidates are deliberately matched against distinct chromosomes in the pool,and so never compete with one another. It is quite clear that the incremental approach iscloser to the spirit of the original Genitor algorithm; it is equivalent to selecting theP bestchromosomes out of theP + N members of the joint population of existing chromosomesand candidates. The alternative, which makes little intuitive sense, can lead to situationswhere good chromosomes are displaced by inferior ones, which is quite contrary to thespirit of rank-based conditionalreplacement. Incremental replacement is also used in thescatter search algorithm, together with techniques to avoid duplicating previously-testedsolutions.

The contrast between Holland’sunconditional uniformalgorithm and Genitor’scondi-tional rank-basedalgorithm immediately suggests two other combinations: by separating

184 HUNTER

the conditionality element from the replacement-selection method, we gainconditionaluniformreplacement andunconditional rank-basedreplacement.

In unconditional rank-basedreplacement, we must again address the question of whichchromosomes get replaced. Curiously, the answer here appears to be the opposite of thatfor conditional rank-basedreplacement. If we do unconditionalincrementalreplacementof the worst member, while maintaining rank, we actually end up with a slightly cock-eyedversion of theconditional rank-basedreplacement algorithm. A candidate which is fitterthan the worst member of the pool will be inserted at whatever position its ranking dictates,precisely as it would be in the unconditional algorithm. The algorithm actually only differsfrom the conditional algorithm when the candidate is inferior to the worst member of thepool, which it will displace regardless. If there are any more candidates to be considered,they will certainly expel this impostor in turn. The net effect is that the algorithm operatesprecisely like theconditional rank-basedalgorithm, except that the last candidate which didnot deserve to be inserted, is! This is clearly an unsatisfactory modification of the algorithm.

In contrast, thedistinctapproach withunconditional rank-basedreplacement is to replacethe N worst members of the pool with theN candidates, irrespective of fitness. This hasa promising interpretation: it is a form of super-elitism, where an arbitrary number of thetop-ranking solutions can be maintained undisturbed on each generation. Sugal supportsthis version of the algorithm.

The other additional approach generated by separating conditionality of replacement fromreplacement-selection isconditional uniformreplacement. This is a simple modification ofHolland’s GA where each candidate is matched against an arbitrarily selected member ofthe pool, and replaces it only if fitter than it. The implications in terms of better exploitativeand lower explorative power are obvious. However, the issue again arises as to whetherthe algorithm should beincrementalor distinct, i.e., should each child be inserted in turn,independently, thus possibly competing with previously inserted children? The issue is lessclear-cut here, and Sugal uses thedistinctversion of the algorithm, partly for compatibilitywith the basic GA, and partly because theincrementalversion is supported as a subset oftournamentreplacement (discussed later in this paper).

While conditionality of replacement can be extracted as a clearly independent part of theprocess, the incremental/distinct feature works quite differently depending on the replace-ment method. It may also be meaningless for some replacement methods (for example,parental replacement). Therefore, the incremental/distinct feature is included in Sugal onlyas a facet of the replacement method, rather than as a control parameter in its own right.

Table 1 summarises the relationship of Sugal’s various replacement styles with varioustypes of Genetic Algorithm.

Table 1. Some replacement strategies in Sugal.

Condition

Replacement Unconditional If improved

Uniform Holland’s GA “Conditional” GA

Ranked Super-elitist Genitor extension


Integrating simulated annealing

The separation of conditionality of replacement from the replacement method allows fur-ther hybridisation of the Sugal algorithm. Only two possible conditions have so far beendiscussed:unconditional, in which a candidate displaces a chromosome from the poolwhatever the relative fitness, andif improved, in which a candidate displaces a chromo-some from the pool if fitter than it. However, a number of other conditional schemes canbe devised. The best known of these isannealing.

In the Simulated Annealing algorithm (Bohachevsky (1986)), a single solution is main-tained (as opposed to the Genetic Algorithm’s pool). At each stage of the algorithm, a newsolution is generated by slightly adjusting the old one (this is analogous to mutation in theGenetic Algorithm). The new solution is evaluated. If it is better than the old one, then itreplaces it. If it is inferior, itmaystill replace the old solution. The chance of an inferiornew solution replacing a superior existing solution is related to the difference in the fitness,and to a quantity known as the temperature. A lower temperature decreases the chance ofan inferior child displacing the parent. The typical approach in simulated annealing is tostart with a high temperature (which makes the algorithm like unconditional replacement),then to gradually lower it (so that the algorithm eventually becomes like conditional re-placement). In the initial stages the high temperature allows the algorithm to escape localminima and to locate globally good areas for solutions; in the latter stages it (hopefully)settles down into the global minimum.

The separation of replacement conditionality allows Simulated Annealing to be integratedinto Sugal, and combined arbitrarily with the other Genetic Algorithm features. Annealingis simply supported as a special replacement condition. Combined with some of the otherreplacement options (discussed below), this also allows Sugal to act as a simple or parallelsimulated annealing package with no genetic features at all! It is also simple to extend Sugal,by adding additional forms of replacement condition. For example, the replacement chancecould be related to pool diversity (which is measured by Sugal) or fitness improvementrates, to produce algorithms which actively avoid over-convergence.

Other replacement options

Other forms of replacement slot neatly into the Sugal algorithm. Intournamentreplace-ment, a number of members of the pool are randomly selected (with a uniform distribution),and the worst of them faces a candidate for possible replacement (depending on the replace-ment condition). This method is incremental (i.e., a candidate may end up replacing anothercandidate which has just been inserted into the pool), so with a tournament size of 1 it is pos-sible to recover the incremental version ofuniformreplacement. Tournament replacementrepresents a good alternative to rank-based methods: it shares their tendency to replaceinferior and retain superior chromosomes, while having far lower computational costs.

In crowding replacement (Goldberg (1989)), a number of members of the pool are uni-formly selected, and the onemost similar tothe candidate faces replacement. The intent isto prevent over-convergence by making it likely that children will replace their parents orclose-relatives, promoting niching. Crowding replacement is inherently incremental.

186 HUNTER

In parentalreplacement, candidates are matched against their own parents (if crossoverhas been used, the two children are arbitrarily assigned one of the two parents each). Thisis an even more extreme method of preventing premature convergence than crowding, sincegood solutions cannot displace unrelated inferior ones! Parental replacement is part in-cremental, part distinct; since a candidate is naturally matched against its parent, but thatparent may have several children, the effect is that the children of a particular parent mayend up in an incremental competition with each other, but not with other candidates. Per-haps surprisingly, the parental replacement algorithm can perform adequately, providingthat replacement is conditional. Without crossover, the algorithm can then perform a paral-lel mutation-based search. With crossover, good genes can still be propagated geneticallyas good chromosomes sometimes mate with bad chromosomes; the bad parent may thenbe replaced by the superior child while the good parent is retained. This is a rather oddvariation on the GA theme, and I am not aware of any published experiments using it (theidea was suggested to me informally during discussions at the Polymodel conference inSunderland, 1995, and I apologise to the unidentified author, whom I am unable to citecorrectly). However, parental replacement is provided in Sugal principally to supportnon-geneticalgorithms. A uniform selection operator is provided to complement it in this respect(it selects parents with a uniform non-overlapping probability; i.e., the entire pool can be se-lected, each to be replaced by its own child). With uniform selection, parental replacement,crossover suppressed and annealed replacement, Sugal performs parallel Simulated Anneal-ing; with a population of one this reduces to the standard Simulated Annealing algorithm.

Reevaluation

Sugal includes an additional phase in the algorithm, which supports some relatively obscureforms of the algorithm: reevaluation. Reevaluation takes place after replacement. It can beused in two ways: forweak evaluationandco-evolutionary problems.

In some problem domains there is a stochastic element in the evaluation of chromosomes.We call this situationweak evaluation. If this is the case, a particular chromosome mayreceive an unusually high fitness which does not reflect its true value. If it retains thisfitness indefinitely, it will probably remain in the pool for a long time, and produce a largenumber of offspring. To avoid this problem, Sugal can be configured to re-evaluate anychromosomes which have survived unreplaced from one generation to the next.

In co-evolutionary problems, the fitness of an individual chromosome depends on allthe other chromosomes: they must be evaluated together as a single process. For co-evolutionary problems, Sugal can be supplied with a pool reevaluation procedure, ratherthan a chromosome evaluation procedure. Replacement takes place as normal, except thatconditional replacement is not possible (the fitness of the candidates cannot be determineduntil they are in the pool, so it is not possible to compare their fitness with existing chro-mosomes). After replacement, the entire pool is simultaneously “reevaluated”.

Sugal datatypes

An issue of no little importance in Genetic Algorithms is the best representation of com-plicated entities. Holland (1975) argues strongly, with the support of the schema theorem,


that a low-cardinality alphabet is superior. Since binary is the lowest cardinality alphabetavailable, Holland’s GA is specified solely in terms of binary chromosomes. Fogel (1990),in contrast, believes that in real-valued function optimisation a high-cardinality alphabet(namely, strings of real numbers) is better. Even if one decides to use a binary representation,it is typically necessary to extract integer or real parameter values using some well-definedtransformation.

Sugal is designed to support a variety of datatypes in an integrated fashion. At one level,this simply means that Sugal recognises a number of datatypes (including bit, integers,unsigned integers, reals, symbols and permutations), and has operators appropriate to these(including Gaussian, Step and Uniform mutation of numeric datatypes). However, Sugalalso supports non-homogeneous chromosomes (which include a mixture of datatypes in onestring) and facilitates comparison of different representations and interpretations. This isbecause Sugal maps all datatypes into bitwise strings in the computer memory. By defaultSugal respects the datatype of a string (for example, crossover will normally only selectbitwise crossover loci between numbers in an integer datatype chromosomes). However, itis quite easy to customise Sugal to intermix bit and higher-cardinality approaches.

As an example of this, thedejongtest program supplied with Sugal can have the datatypeswitched between integer and bit datatypes. Although originally designed to test Holland’sbitwise GA, De Jong’s test set (De Jong (1975), Goldberg (1989)) consists of functions whichare actually defined on integers (the chromosome being simply the bitwise representationof the integer parameters). Some cursory experiments, reported in the Sugal tutorials(Hunter (1995)), suggest that (in this case, at least) a higher-cardinality representation isbetter—provided that it is exploited by using sophisticated mutation operators. With aninteger representation it is possible to use a time-dependent incremental mutation operator,which makes large mutations initially, and gradually reduces the range as the algorithmprogresses. This relatively sophisticated form of mutation is able to do a wide initial searchand a focused terminal search. It is interesting to note that, in this context, any form ofinteger-based algorithm with less sophistication than this proved inferior to the standardbitwise algorithm, which can perform a rudimentary time-focused search by using crossoverto select first for high-order, then for low-order, bits in the integer parameters. Althoughit is notoriously dangerous to draw general conclusions from results of GA experimentswith specific problems, I would argue that a higher level representation—if backed up withappropriate specialised operators—will normally out-perform a lower level representation.

In a related context, Davis (1991) suggests that Genetic Algorithms are most usefulwhen operating as hybrid algorithms with domain-specific search techniques (typicallyincluded in the Genetic Algorithm as special forms of mutation, since they alter a singlechromosome in some fashion). For example, a number of authors have compared GAtraining of neural networks with backpropagation. The latter algorithm far out-performs anaive GA search of weight space, since it exploits the high-level gradient information whichthe GA is necessarily unaware of. More useful hybrid algorithms (Harp (1989)) use the GAto specify some aspects of the neural network structure, usually selected heuristically, thenuse backpropagation to train the resulting networks. In short: if you have a higher ordersearch method, use it. For this reason, Sugal is carefully designed to make the integrationof additional operators easy.

188 HUNTER

A sample experiment

To demonstrate the versatility of the package, we report the results of an experiment toconfirm Whitley’s (Whitley (1989)) claims that Genitor achieves faster convergence thanHolland’s GA, and we exploit Sugal’s flexibility to determine which features of Genitorcontribute most heavily to its performance.

To simplify experimentation, Sugal includes a facility to gather statistics on individualruns of the Genetic Algorithm, and also to gather aggregate statistics across a number ofruns. At the level of individual runs, Sugal can gather (and graph) population statistics in-cluding Minimum, Maximum, Mean and Standard Deviations of fitness, and also a measureof population diversity (related to mutual Hamming distances for bitwise Genetic Algo-rithms, with appropriate equivalents for symbolic or numeric Genetic Algorithms). Sugalcan also conduct a number of runs and gather aggregate statistics, including the Minimum,Maximum, Mean and Standard Deviation of any of the individual statistics, and the user canspecify which parameters of the Genetic Algorithm should be altered across the multipleruns. In these experiments, we choose to alter the random number generator’s seed through50 values, and report the aggregate Mean of the population fitness Means. These aggre-gate Means characterise the typical performance of the algorithm with given parametersettings. The graphs are output from Sugal in TAB-separated format and then loaded intoa spreadsheet for further analysis and plotting.

The experiments were conducted using the De Jong test set (F1–F5), an implementationof which is included in the Sugal distribution. To facilitate the comparison, some aspects ofthe Genetic Algorithm are fixed across all experiments, using values typically recommendedin the literature (see Table 2).

The population is actually much lower than is usually recommended; however, theDe Jong test set problems are very simple and do not require a larger population size.

The “standard” Genetic Algorithm had the following additional settings: Selection wasusing the Expected Value Model (called “integral roulette” in Sugal) and Elitism wasused. Barring the elite member, the entire population was unconditionally replaced at eachgeneration.

In these experiments, we compare a number of forms of Genetic Algorithm. Besides thestandard Genitor and “Holland plus elitism” Genetic Algorithms, we include some hybridalgorithms as described in the last section. These are: a “Super-elitist” model, which retains20% of the population unaltered on every generation, but is in other respects the same as the

Table 2.

Parameter Value

Population 20

Evaluations 2000

Mutation One-point, rate 1.0 per chromosome

Crossover Bitwise inversion, rate 0.6

Fitness normalisation Linear scaling (bias 2.0)


Figure 1. De Jong F2, algorithms compared.

standard Genetic Algorithm; a standard Genetic Algorithm using Genitor’s ranked fitnessnormalisation procedure; and a standard Genetic Algorithm using conditional replacement.

Figure 1 shows the progress over the first 50 generations (or equivalent number of eval-uations) on the De Jong F2 problem. Results on the other De Jong problems, despite thevery different nature of the problems, are similar (i.e., the relative effectiveness of the var-ious algorithms remains the same). As expected, the result confirms Whitley’s claim thatGenitor converges substantially faster than the standard Genetic Algorithm.

What is interesting is the performance of the various hybrid algorithms. The second-best algorithm is a standard Genetic Algorithm with one critical alteration: replacementis conditional. When the parental population is replaced, each child is matched againstan arbitrarily selected member of the parental population, and is inserted only if of higherfitness. This is not a standard form of Genetic Algorithm at all, and yet this experimentindicates that it is extremely effective. In contrast, the super-elitist model (where the best20% of the population is retained unaltered) performs better than the standard GeneticAlgorithm, but falls far short of Genitor performance.

The implication appears to be that Genitor’s superior performance is largely due to therejectionof poor children. Both super-elitism and conditional replacement have this effect,but it is more pronounced in conditional replacement, because in super-elitism poor childrenstill unconditionally replace 80% of the population. Genitor’s use of ranking information(once we discount the “super-elitist” effect) appears to be of little significance. In particular,the standard algorithm modified to use Ranked Selection fares no better than a standardalgorithm with linearly scaled fitness (although if the fitness function were extremely badlybehaved, ranking might produce benefits there too).

This standard algorithm modified to use conditional replacement can prove extremelyuseful. Genitor is computationally inefficient in requiring that the population be maintainedin ranked-order throughout (on these simple test experiments Genitor runs significantlyslower than the other algorithms). In many real-world problems the evaluation of thefitness function dominates the time spent by the algorithm, but this is not always true, andwhen the efficiency of the Genetic Algorithm itself is important the conditional modification

190 HUNTER

Figure 2. Tournament replacement-selection compared. Tour2 (Conditional Tournament) is coincident withconditional.

may be extremely helpful. Moreover, the algorithm with conditional replacement is moreeasily adapted to Parallel or Distributed implementations, any by a simple extension theconditional replacement can be merged with the concept of Simulated Annealing to producean algorithm with fast convergence combined with the capability to escape local minima.

To confirm the primacy of replacement-conditionality in determining the speed of con-vergence, a further pair of experiments were conducted, using tournament replacement(where the member of the population to be replaced is selected by a tournament; the low-est fitness member of the randomly assembled tournament is considered for replacement).The tournament method can be combined with conditional and unconditional replacement(i.e., the loser of the tournament is either conditionally or unconditionally replaced by thechild chromosome). The results confirm our hypothesis: the tournament scheme with con-ditional replacement behaves almost identically with the simple scheme with conditionalreplacement, whereas the unconditional tournament is better than the standard algorithm(the tournament does not prevent poor children from being inserted, but it does make itmuch more likely that they will be rejected on the succeeding generation), but falls far shortof the conditional version (see figure 2).

Conclusion

This paper has outlined the Sugal Genetic Algorithm, a generalised GA which subsumesthe standard models as special cases.

Consideration of the various possible algorithms leads to distinctions betweenconditionalandunconditional, rank-basedandnon-rank-based, andincrementalanddistinctmethods ofreplacement. Separating conditionality of replacement from replacement-selection allowsthe algorithm to be further hybridised; for example, with Simulated Annealing.

By decomposing the specification of various published algorithms, and uniting the sepa-rated features in a single framework, Sugal clarifies the relationship between the algorithms,produces a range of hybrid algorithms, and permits the independent study of the various


features which go to make up the various Genetic Algorithms’ characters. It is hoped thatthis will make it possible to conduct more rigorous comparative research than has beengenerally available to date. The comparative abilities of Sugal are further improved by itsintegrated treatment of datatypes (all are built on top of bit-strings), which makes it possibleto mix representations.

This generalised algorithm, together with Sugal’s integrated support for various datatypes,and ease of customisation, make Sugal ideal for experimentation in a variety of problemdomains.

Appendix

This appendix summarises the main capabilities of the Sugal Genetic Algorithm:

Data types Bitwise, integers and reals (various types, including custom precision),symbolic.

Crossover One-point, two-point, uniform,n-point (may apply several separately).Mutation Bitwise invert, reinitialisation, uniform, step and Gaussian numeric; time-

decaying mutation size (may apply several separately).Normalisation Biased, Linearly scaled, Mean-scaled, ranked linear or geometric (min-

imisation and maximisation supported in all cases).Selection Uniform, Roulette, Expected Value Roulette, Tournament.Replacement Replacement-selection: Uniform, Ranked, Tournament, Crowding,

Parental; Replacement condition: Unconditional, Conditional, Anneal-ing; Elitism; Replacement rate: any proportion.

Stoppingconditions

No. generations, fitness target, fitness convergence, diversity convergence.

Statistics Fitness Mean, Minimum, Maximum, Standard Deviation; Diversity mea-sures (Mean Hamming Distance and symbolic equivalent; RMS). Aggre-gates across multiple experiments. Graphs of these.

Miscellaneous Windows and UNIX / MOTIF versions, plus batch (file-based). Config-urable user-interface and algorithm.

References

Baker, J.E. (1985). “Adaptive Selection Methods for Genetic Algorithms.”Proc. First Int. Conf. on GeneticAlgorithms and Their Applications, pp. 101–111.

Bohachevsky, I.O., M.E. Johnson, and L.S. Myron. (1986). “Generalized Simulated Annealing for FunctionOptimization,”Technometrics28(3), 209–217.

Davis, L. (1991).Handbook of Genetic Algorithms. Van Nostrand Reinhold.De Jong, K.A. (1975). “An Analysis of the Behavior of a Class of Genetic Adaptive Systems.” Doctoral Dissertation,

University of Michigan. Dissertation Abstracts International 36(10), 5140B.Fogel, L.J., A.J. Owens, and M.J. Walsh. (1966).Artificial Intelligence Through Simulated Evolution. New York:

John Wiley.Fogel, D.B., L.J. Fogel, and V.W. Porto. (1990). “Evolving Neural Networks,”Biological Cybernetics63, 487–493.

192 HUNTER

Glover, F. (1977). “Heuristics for Integer Programming Using Surrogate Constraints,”Decision Sciences8(1),156–166.

Glover, F. (1997). “A Template for Scatter Search and Path Relinking.” In J.K. Hao, E. Lutton, E. Ronald, M.Schoenauer, and D. Snyers (eds.),Lecture Notes in Computer Science, pp. 1–45.

Goldberg, D. (1989).Genetic Algorithms in Search, Optimization and Machine Learning. Addison-Wesley.Harp, S.A., T. Samad, and A. Guha. (1989). “Towards the Genetic Synthesis of Neural Networks.”Int. Conf. on

Genetic Algorithms, pp. 360–369.Holland, J. (1975).Adaptation in Natural and Artificial Systems. MIT Press.Hunter. (1995). “The Sugal Genetic Algorithms Package.” http://osiris.sunderland.ac.uk/ahu/sugal/home.htmlSchwefel, H. (1981).Numerical Optimization of Computer Models. Chicester: John Wiley.Whitley, D. (1989). “The GENITOR Algorithm and Selective Pressure: Why Rank-Based Allocation of Repro-

ductive Trials is Best.”Proc. Third Int. Conf. on Genetic Algorithms. Morgan Kauffman.

crossing over genetic algorithms: the sugal generalised ga

Documents