Genetic Algorithms (GA)

OVERVIEW
A class of probabilistic optimization algorithms
Inspired by the biological evolution process
Uses concepts of “Natural Selection” and
“Genetic Inheritance” (Darwin 1859)
Originally developed by John Holland (1975)

Introduction to Genetic Algorithms 1

 GA overview (cont)

Particularly well suited for hard problems where

little is known about the underlying search space
Widely-used in business, science and engineering

Introduction to Genetic Algorithms 2

 Classes of Search Techniques
Search Techniqes

Calculus Base Guided random search Enumerative

Techniqes techniqes Techniqes

Fibonacci Sort DFS Dynamic BFS

Programming

Tabu Search Hill Simulated Evolutionary

Climbing Anealing Algorithms

Genetic Genetic
Programming Algorithms

Introduction to Genetic Algorithms 3

A genetic algorithm maintains a
population of candidate solutions
for the problem at hand,
and makes it evolve by
iteratively applying
a set of stochastic operators

Introduction to Genetic Algorithms 4

 Stochastic operators

Selection replicates the most successful

solutions found in a population at a rate
proportional to their relative quality
Recombination decomposes two distinct
solutions and then randomly mixes their parts
to form novel solutions
Mutation randomly perturbs a candidate
solution

Introduction to Genetic Algorithms 5

 The Metaphor

Nature Genetic Algorithm

Environment Optimization problem

Individuals living in that Feasible solutions

environment
Individual’s degree of Solutions quality (fitness
adaptation to its function)
surrounding environment

Introduction to Genetic Algorithms 6

 The Metaphor (cont)
Nature Genetic Algorithm

A population of organisms A set of feasible solutions

(species)
Selection, recombination Stochastic operators
and mutation in nature’s
evolutionary process
Evolution of populations to Iteratively applying a set
suit their environment of stochastic operators on
a set of feasible solutions

Introduction to Genetic Algorithms 7

 The Metaphor (cont)

The computer model introduces simplifications

(relative to the real biological mechanisms),
BUT
surprisingly complex and interesting structures
have emerged out of evolutionary algorithms

Introduction to Genetic Algorithms 8

Simple Genetic Algorithm
produce an initial population of individuals
evaluate the fitness of all individuals
while termination condition not met do
select fitter individuals for reproduction
recombine between individuals
mutate individuals
evaluate the fitness of the modified individuals
generate a new population
End while

Introduction to Genetic Algorithms 9

 The Evolutionary Cycle
parents
selection modification
modified
offspring
& initiate
population evaluation
evaluate evaluated offspring
deleted
members

discard

Introduction to Genetic Algorithms 10

Introduction to Genetic Algorithms 11
 Example:
the MAXONE problem

Suppose we want to maximize the number of

ones in a string of l binary digits
Is it a trivial problem?
It may seem so because we know the answer in
advance
However, we can think of it as maximizing the
number of correct answers, each encoded by 1,
to l yes/no difficult questions`
Introduction to Genetic Algorithms 12
 Example (cont)

An individual is encoded (naturally) as a

string of l binary digits
The fitness f of a candidate solution to the
MAXONE problem is the number of ones in
its genetic code
We start with a population of n random
strings. Suppose that l = 10 and n = 6

Introduction to Genetic Algorithms 13

 Example (initialization)
We toss a fair coin 60 times and get the
following initial population:
s1 = 1111010101 f (s1) = 7
s2 = 0111000101 f (s2) = 5
s3 = 1110110101 f (s3) = 7
s4 = 0100010011 f (s4) = 4
s5 = 1110111101 f (s5) = 8
s6 = 0100110000 f (s6) = 3

Introduction to Genetic Algorithms 14

 Example (selection1)

Next we apply fitness proportionate selection with the

roulette wheel method: Individual i will have a f (fi()i)
i

probability to be chosen
We repeat the extraction 1 Area is
2
as many times as the n
Proportional
to fitness
number of individuals we value
3
need to have the same
parent population size 4
(6 in our case)

Introduction to Genetic Algorithms 15

 Example (selection2)

Suppose that, after performing selection, we get

the following population:
s1` = 1111010101 (s1)
s2` = 1110110101 (s3)
s3` = 1110111101 (s5)
s4` = 0111000101 (s2)
s5` = 0100010011 (s4)
s6` = 1110111101 (s5)

Introduction to Genetic Algorithms 16

 Example (crossover1)

Next we mate strings for crossover. For each

couple we decide according to crossover
probability (for instance 0.6) whether to actually
perform crossover or not
Suppose that we decide to actually perform
crossover only for couples (s1`, s2`) and (s5`, s6`).
For each couple, we randomly extract a
crossover point, for instance 2 for the first and 5
for the second

Introduction to Genetic Algorithms 17

 Example (crossover2)
Before crossover:
s1` = 1111010101 s5` = 0100010011
s2` = 1110110101 s6` = 1110111101

After crossover:
s1`` = 1110110101 s5`` = 0100011101
s2`` = 1111010101 s6`` = 1110110011

Introduction to Genetic Algorithms 18

 Example (mutation1)
The final step is to apply random mutation: for each bit that
we are to copy to the new population we allow a small
probability of error (for instance 0.1)
Before applying mutation:
s1`` = 1110110101
s2`` = 1111010101
s3`` = 1110111101
s4`` = 0111000101
s5`` = 0100011101
s6`` = 1110110011
Introduction to Genetic Algorithms 19
Example (mutation2)
After applying mutation:
s1``` = 1110100101 f (s1``` ) = 6
s2``` = 1111110100 f (s2``` ) = 7
s3``` = 1110101111 f (s3``` ) = 8
s4``` = 0111000101 f (s4``` ) = 5
s5``` = 0100011101 f (s5``` ) = 5
s6``` = 1110110001 f (s6``` ) = 6

Introduction to Genetic Algorithms 20

 Example (end)

In one generation, the total population fitness

changed from 34 to 37, thus improved by ~9%

At this point, we go through the same process

all over again, until a stopping criterion is met

Introduction to Genetic Algorithms 21

Introduction to Genetic Algorithms 22
 Components of a GA

A problem definition as input, and

Encoding principles (gene, chromosome)

Initialization procedure (creation)
Selection of parents (reproduction)
Genetic operators (mutation, recombination)
Evaluation function (environment)
Termination condition

Introduction to Genetic Algorithms 23

Representation (encoding)

Possible individual’s encoding

 Bit strings (0101 ... 1100)
 Real numbers (43.2 -33.1 ... 0.0 89.2)
 Permutations of element (E11 E3 E7 ... E1 E15)
 Lists of rules (R1 R2 R3 ... R22 R23)
 Program elements (genetic programming)
 ... any data structure ...

Introduction to Genetic Algorithms 24

 Representation (cont)

When choosing an encoding method rely on the

following key ideas

Use a data structure as close as possible to the

natural representation
Write appropriate genetic operators as needed
If possible, ensure that all genotypes correspond
to feasible solutions
If possible, ensure that genetic operators
preserve feasibility

Introduction to Genetic Algorithms 25

 Initialization

Start with a population of randomly

generated individuals, or use
- A previously saved population
- A set of solutions provided by
a human expert
- A set of solutions provided by
another heuristic algorithm

Introduction to Genetic Algorithms 26

 Selection

Purpose: to focus the search in promising

regions of the space
Inspiration: Darwin’s “survival of the fittest”
Trade-off between exploration and exploitation
of the search space

Next we shall discuss possible selection methods

Introduction to Genetic Algorithms 27

Fitness Proportionate Selection

Derived by Holland as the optimal trade-off

between exploration and exploitation

Drawbacks
Different selection for f1(x) and f2(x) = f1(x) + c
Superindividuals cause convergence (that may
be premature)

Introduction to Genetic Algorithms 28

 Linear Ranking Selection

Based on sorting of individuals by decreasing fitness

The probability to be extracted for the ith individual
in the ranking is defined as
1 i 1 
p (i )     2 (   1)  ,1    2
n n  1

where can be interpreted as

the expected sampling rate of
the best individual

Introduction to Genetic Algorithms 29

Local Tournament Selection

Extracts k individuals from the population

with uniform probability (without re-insertion)
and makes them play a “tournament”,
where the probability for an individual to win
is generally proportional to its fitness
Selection pressure is directly proportional to
the number k of participants

Introduction to Genetic Algorithms 30

Recombination (Crossover)

* Enables the evolutionary process

to move toward promising
regions of the search space
* Matches good parents’ sub-solutions
to construct better offspring

Introduction to Genetic Algorithms 31

 Mutation

Purpose: to simulate the effect of errors that

happen with low probability during duplication

Results:
- Movement in the search space
- Restoration of lost information to the population

Introduction to Genetic Algorithms 32

Evaluation (fitness function)

Solution is only as good as the evaluation

function; choosing a good one is often the
hardest part
Similar-encoded solutions should have a
similar fitness

Introduction to Genetic Algorithms 33

 Termination condition

Examples:

A pre-determined number of generations or time

has elapsed
A satisfactory solution has been achieved
No improvement in solution quality has taken
place for a pre-determined number of generations

Introduction to Genetic Algorithms 34

Introduction to Genetic Algorithms 35
 Another Example:
The Traveling Salesman
Problem (TSP)
The traveling salesman must visit every city in his
territory exactly once and then return to the starting
point; given the cost of travel between all cities, how
should he plan his itinerary for minimum total cost of
the entire tour?
TSP  NP-Complete
Note: we shall discuss a single possible approach
to approximate the TSP by GAs
Introduction to Genetic Algorithms 36
TSP (Representation, Evaluation,
Initialization and Selection)
A vector v = (i1 i2… in) represents a tour (v is a
permutation of {1,2,…,n})

Fitness f of a solution is the inverse cost of the

corresponding tour

Initialization: use either some heuristics, or a

random sample of permutations of {1,2,…,n}

We shall use the fitness proportionate selection

Introduction to Genetic Algorithms 37

 TSP (Crossover1)
OX – builds offspring by choosing a sub-sequence of
a tour from one parent and preserving the relative
order of cities from the other parent and feasibility
Example:
p1 = (1 2 3 4 5 6 7 8 9) and
p2 = (4 5 2 1 8 7 6 9 3)
First, the segments between cut points are copied into offspring
o1 = (x x x 4 5 6 7 x x) and
o2 = (x x x 1 8 7 6 x x)
Introduction to Genetic Algorithms 38
 TSP (Crossover2)
Next, starting from the second cut point of one parent, the
cities from the other parent are copied in the same order
The sequence of the cities in the second parent is
9–3–4–5–2–1–8–7–6
After removal of cities from the first offspring we get
9–3–2–1–8
This sequence is placed in the first offspring
o1 = (2 1 8 4 5 6 7 9 3), and similarly in the second
o2 = (3 4 5 1 8 7 6 9 2)

Introduction to Genetic Algorithms 39

 TSP (Inversion)

The sub-string between two randomly selected

points in the path is reversed

Example:
(1 2 3 4 5 6 7 8 9) is changed into (1 2 7 6 5 4 3 8 9)

Such simple inversion guarantees that the

resulting offspring is a legal tour

Introduction to Genetic Algorithms 40

Introduction to Genetic Algorithms 41
 GAs: Why Do They Work?

In this section we take an in-depth look at the

working of the standard genetic algorithm,
explaining why GAs constitute an effective
search procedure

For simplicity we discuss binary string

representation of individuals

Introduction to Genetic Algorithms 42

 Notation (schema)

{0,1,#} is the symbol alphabet, where # is a

special wild card symbol
A schema is a template consisting of a string
composed of these three symbols
Example: the schema [01#1#] matches the
strings: [01010], [01011], [01110] and [01111]

Introduction to Genetic Algorithms 43

 Notation (order)
The order of the schema S (denoted by o(S)) is
the number of fixed positions (0 or 1) presented in
the schema

Example: for S1 = [01#1#], o(S1) = 3

for S2 = [##1#1010], o(S2) = 5

The order of a schema is useful to calculate

survival probability of the schema for mutations
l-o(S)
There are 2 different strings that match S

Introduction to Genetic Algorithms 44

 Notation (defining length)

The defining length of schema S (denoted by (S)) is the

distance between the first and last fixed positions in it

Example: for S1 = [01#1#], (S1) = 4 – 1 = 3,

for S2 = [##1#1010], (S2) = 8 – 3 = 5

The defining length of a schema is useful to calculate

survival probability of the schema for crossovers

Introduction to Genetic Algorithms 45

 Notation (cont)

m(S,t) is the number of individuals in the

population belonging to a particular schema S
at time t (in terms of generations)

fS(t) is the average fitness value of strings

belonging to schema S at time t

f (t) is the average fitness value over all strings

in the population

Introduction to Genetic Algorithms 46

 The effect of Selection
Under fitness-proportionate selection the expected
number of individuals belonging to schema S at time
(t+1) is m (S,t+1) = m (S,t) ( fS(t)/f (t) )

Assuming that a schema S remains above average

by 0  c, (i.e., fS(t) = f (t) + c f (t) ), then
t
m (S,t) = m (S,0) (1 + c)

Significance: “above average” schema receives an

exponentially increasing number of strings in the
next generation
Introduction to Genetic Algorithms 47
 The effect of Crossover

The probability of schema S (|S| = l) to survive

crossover is ps(S)  1 – pc((S)/(l – 1))

The combined effect of selection and crossover

yields
m (S,t+1)  m (S,t) ( fS(t)/f (t) ) [1 - pc((S)/(l – 1))]

Above-average schemata with short defining lengths

would still be sampled at exponentially increasing
rates
Introduction to Genetic Algorithms 48
 The effect of Mutation
The probability of S to survive mutation is:
o(S)
ps(S) = (1 – pm)
Since pm<< 1, this probability can be approximated by:
ps(S)  1 – pm·o(S)
The combined effect of selection, crossover and
mutation yields
m (S,t+1)  m (S,t) ( fS(t)/f (t) ) [1 - pc((S)/(l – 1)) -pmo(S)]

Introduction to Genetic Algorithms 49

 Schema Theorem
Short, low-order, above-average schemata receive
exponentially increasing trials in subsequent
generations of a genetic algorithm

Result: GAs explore the search space by short,

low-order schemata which, subsequently, are
used for information exchange during crossover

Introduction to Genetic Algorithms 50

 Building Block Hypothesis

A genetic algorithm seeks near-optimal performance

through the juxtaposition of short, low-order, high-
performance schemata, called the building blocks

The building block hypothesis has been found

to apply in many cases but it depends on the
representation and genetic operators used

Introduction to Genetic Algorithms 51

Building Block Hypothesis (cont)
It is easy to construct examples for which the above
hypothesis does not hold:
S1 = [111#######] and S2 = [########11]
are above average, but their combination
S3 = [111#####11] is much less fit than S4 = [000#####00]
Assume further that the optimal string is S0 = [1111111111]. A
GA may have some difficulties in converging to S0, since it
may tend to converge to points like [0001111100].

Some building blocks (short, low-order schemata) can

mislead GA and cause its convergence to suboptimal points
Introduction to Genetic Algorithms 52
Building Block Hypothesis (cont)

Dealing with deception:

Code the fitness function in an appropriate way
(assumes prior knowledge)
or
Use a third genetic operator, inversion

Introduction to Genetic Algorithms 53

Introduction to Genetic Algorithms 54
 A brief introduction to
Co-evolution

Two or more species evolve and interact

through the fitness function
Closer to real biological systems
Competitive (prey-predator) or Cooperative
Examples: Hillis (competitive), my work
(cooperative)

Introduction to Genetic Algorithms 55

 References
C. Darwin. On the Origin of Species by Means of Natural Selection;
or, the Preservation of flavored Races in the Struggle for Life. John
Murray, London, 1859.
W. D. Hillis. Co-Evolving Parasites Improve Simulated Evolution as
an Optimization Procedure. Artificial Life 2, vol 10, Addison-Wesley,
1991.
J. H. Holland. Adaptation in Natural and Artificial Systems. The
University of Michigan Press, Ann Arbor, Michigan, 1975.
Z. Michalewicz. Genetic Algorithms + Data Structures = Evolution
Programs. Springer-Verlag, Berlin, third edition, 1996.
M. Sipper. Machine Nature: The Coming Age of Bio-Inspired
Computing. McGraw-Hill, New-York, first edition, 2002.
M. Tomassini. Evolutionary algorithms. In E. Sanchez and
M. Tomassini, editors, Towards Evolvable Hardware, volume 1062
of Lecture Notes in Computer Science, pages 19-47. Springer-
Verlag, Berlin, 1996.

Introduction to Genetic Algorithms 56