Evolution

Heres a very oversimplified description of how evolution works

in biology
Organisms (animals or plants) produce a number of offspring
which are almost, but not entirely, like themselves
Variation may be due to mutation (random changes)
Variation may be due to reproduction (offspring have some characteristics

from each parent)

Some of these offspring may survive to produce offspring of their

ownsome wont
The better adapted offspring are more likely to survive
Over time, later generations become better and better adapted

Genetic algorithms use this same process to evolve better

programs
2

GENETIC ALGORITHM
A biologically inspired model of intelligence and the principles
of biological evolution are applied to find solutions to difficult
problems
The problems are not solved by reasoning logically about them;
rather populations of competing candidate solutions are spawned
and then evolved to become better solutions through a process
patterned after biological evolution
Less worthy candidate solutions tend to die out, while those that
show promise of solving a problem survive and reproduce by
constructing new solutions out of their components
3

GENETIC ALGORITHM
GA begin with a population of candidate problem solutions
Candidate solutions are evaluated according to their ability to
solve problem instances: only the fittest survive and combine
with each other to produce the next generation of possible
solutions
Thus increasingly powerful solutions emerge in a Darwinian
universe
This method is heuristic in nature and it was introduced by John
Holland in 1975

Basic Genetic Algorithm

Start with a large population of randomly generated

attempted solutions to a problem

Repeatedly do the following:
Evaluate each of the attempted solutions
Keep a subset of these solutions (the best ones)
Produce next generation from these solutions (using
inheritance and mutation)
Quit when you have a satisfactory solution (or you run out of time)

GENETIC ALGORITHM
Basic Algorithm
begin
set time t = 0;
initialise population P(t) = {x1t, x2t, , xnt} of solutions;
while the termination condition is not met do
begin
evaluate fitness of each member of P(t);
select some members of P(t) for creating offspring;
produce offspring by genetic operators;
replace some members with the new offspring;
set time t = t + 1;
end
end

GENETIC ALGORITHM
Representation of Solutions: The Chromosome
Gene: A basic unit, which represents one characteristic of the
individual. The value of each gene is called an allele
Chromosome: A string of genes; it represents an individual i.e. a
possible solution of a problem. Each chromosome represents a
point in the search space
Population: A collection of chromosomes
An appropriate chromosome representation is important for the
efficiency and complexity of the GA

GENETIC ALGORITHM
Evaluation/Fitness Function
It is used to determine the fitness of a chromosome
Creating a good fitness function is one of the challenging tasks of
using GA

GENETIC ALGORITHM
Fitness Function
The fitness function can be the score of the classification
accuracy of the rule-set over a set of provided training examples
Often other criteria may be included as well, such as the
complexity of the rules or the size of the rule set

GENETIC ALGORITHM
Selection Operators (Algorithms)
They are used to select parents from the current population
The selection is primarily based on the fitness. The better the
fitness of a chromosome, the greater its chance of being selected
to be a parent
The most popular method of selection is Proportionate Selection

GENETIC ALGORITHM
Reproduction Operators
Genetic operators are applied to chromosomes that are selected to
be parents, to create offspring
Basically of two types: Crossover and Mutation
Crossover operators create offspring by recombining the
chromosomes of selected parents
Mutation is used to make small random changes to a
chromosome in an effort to add diversity to the population

GENETIC ALGORITHM
Reproduction Operators: Mutation
Mutation is another important genetic operator
Mutation takes a single candidate and randomly changes some
aspect (gene) of it
For example, mutation may randomly select a bit in the pattern
and change it, switching a 1 to a 0 or to # (dont care)

Simple example

Suppose your organisms are 32-bit computer words

You want a string in which all the bits are ones
Heres how you can do it:
Create 100 randomly generated computer words
Repeatedly do the following:

Count the 1 bits in each word

Exit if any of the words have all 32 bits set to 1
Keep the ten words that have the most 1s (discard the rest)
From each word, generate 9 new words as follows:
Pick a random bit in the word and toggle (change) it

Note that this procedure does not guarantee that the next

generation will have more 1 bits, but its likely

13

Realistic Example
Suppose you have a large number of (x, y) data points
For example, (1, 4), (3, 9), (5, 8), ...

You would like to fit a polynomial (of up to degree 1) through these data

points

That is, you want a formula y = mx + c that gives you a reasonably

good fit to the actual data

Heres the usual way to compute goodness of fit:

Compute the sum of (actual y predicted y)2 for all the data points

The lowest sum represents the best fit

You can use a genetic algorithm to find a pretty good solution

Realistic Example
Your formula is y = mx + c
Your unknowns are m and c; where m and c are integers
Your representation is the array [m, c]
Your evaluation function for one array is:
For every actual data point (x, y)

Compute = mx + c

Find the sum of (y )2 over all x

The sum is your measure of badness (larger numbers are worse)

Example: For [m,c] = [5, 7] and the data points (1, 10) and (2, 13):

= 5x + 7 = 12 when x is 1

= 5x + 7 = 17 when x is 2

Now compute the badness

(10 - 12)2 + (13 17)2 = 22 + 42 = 20

If these are the only two data points, the badness of [5, 7] is 20

Realistic Example
Your GA might be as follows:
Create two-element arrays of random numbers
Repeat 50 times (or any other number):
For

each of the arrays, compute its badness (using all data

points)

Keep

the best arrays (with low badness)

From

the arrays you keep, generate new arrays as follows:

Convert the numbers in the array to binary, toggle one of

the bits at random

Quit if the badness of any of the solution is zero

After all 50 trials, pick the best array as your final answer

Realistic Example
(x, y) : {(1,5) (3, 9)}
[2 7][1 3] (initial random population, where m and c represent genes)

= 2x + 7 = 9 when x is 1

= 2x + 7 = 13 when x is 3

Badness: (5 9)2 + (9 13)2 = 42 + 42 = 32

= 1x + 3 = 4 when x is 1

= 1x + 3 = 6 when x is 3

Badness: (5 4)2 + (9 6)2 = 12 + 32 = 10

Now, lets keep the one with low badness [1 3]

Binary representation [001 011]
Apply mutation to generate new arrays [011 011]
Now we have [1 3] [3 3] as the new population considering that we keep

the two best individuals

Realistic Example
(x, y) : {(1,5) (3, 9)}
[1 3][3 3] (current population)

= 1x + 3 = 4 when x is 1

= 1x + 3 = 6 when x is 3

Badness: (5 4)2 + (9 6)2 = 1 + 9 = 10

= 3x + 3 = 6 when x is 1

= 3x + 3 = 12 when x is 3

Badness: (5 6)2 + (9 12)2 = 1 + 9 = 10

Lets keep the [3 3]

Representation [011 011]
Apply mutation to generate new arrays [010 011] i.e. [2,3]
Now we have [3 3] [2 3] as the new population

Realistic Example
(x, y) : {(1,5) (3, 9)}
[3 3][2 3] (current population)

= 3x + 3 = 6 when x is 1

= 3x + 3 = 12 when x is 3

Badness: (5 6)2 + (9 12)2 = 1 + 9 = 10

= 2x + 3 = 5 when x is 1

= 2x + 3 = 9 when x is 3

Badness: (5 5)2 + (9 9)2 = 02 + 02 = 0

Solution found [2 3]
y = 2x+3
Note: It is not necessary that the badness must always be zero. It can be some

other threshold value as well.

GENETIC ALGORITHM
Reproduction Operators: Crossover
Crossover operation takes two candidate solutions and divides
them, swapping components to produce two new candidates

GENETIC ALGORITHM
Reproduction Operators: Crossover
Figure illustrates crossover on bit string patterns of length 8
The operator splits them and forms two children whose initial
segment comes from one parent and whose tail comes from the
other
Input Bit Strings
11#0101#

#110#0#1

11#0#0#1

#110101#

Resulting Strings

The simple example

again
Suppose your individuals are 32-bit computer words, and you

want a string in which all the bits are ones

Heres how you can do it:

Create 100 randomly generated computer words
Repeatedly do the following:

Count the 1 bits in each word

Exit if any of the words have all 32 bits set to 1

Keep the 10 words that have the most 1s (discard the rest).

From each word, generate 9 new words as follows:

Choose one of the words

Take the first half of this word and combine it with

the second half of some other word

The simple example

again
Half from one, half from the

other:

A = 0110 1001 0100 1110 1010 1101 1011 0101

B = 1101 0100 0101 1010 1011 0100 1010 0101
----------------------------------------------------------------C = 0110 1001 0100 1110 1011 0100 1010 0101

Mutation vs Crossover
In the simple example of 32-bit words (trying to get all 1s):
The (two-parent, no mutation) approach, if it succeeds, is likely to succeed

much faster

Because up to half of the bits change each time, not just one bit

However, without mutation, it may not succeed at all

By pure bad luck, maybe none of the first randomly generated words
have (say) bit 17 set to 1

Then there is no way a 1 could ever occur in this position as we are

not changing individual bits separately

Another problem is lack of genetic diversity

Maybe some of the first generation did have bit 17 set to 1, but none of
them were selected for the second generation

The best technique in general turns out to be crossover with mutation

GENETIC ALGORITHM
Reproduction Operators: Crossover
The place of split in the candidate solution is an arbitrary choice.
This split may be at any point in the solution
This splitting point may be randomly chosen or changed
systematically during the solution process
Crossover can unite an individual that is doing well in one
dimension with another individual that is doing well in the other
dimension

GENETIC ALGORITHM
Reproduction Operators: Crossover
Two types: Single point crossover & Uniform crossover
Single type crossover
This operator takes two parents and randomly selects a single
point between two genes to cut both chromosomes into two
parts (this point is called cut point)
The first part of the first parent is combined with the second
part of the second parent to create the first child
The first part of the second parent is combined with the
second part of first parent to create the second child
1000010
1110001

1000001
1110010

GENETIC ALGORITHM
Reproduction Operators: Crossover
Uniform crossover
The value of each gene of an offsprings chromosome is
randomly taken from either parent
This is equivalent to multiple point crossover
1000010
1110001

1010010

GENETIC ALGORITHM
Example
Find a number: 001010
You have guessed this binary number. If you write a program to
find it, then there are 26 = 64 possibilities
If you find it with the help of Genetic Algorithm, then the
program gives a number and you tell its fitness
The fitness score is the number of correctly guessed bits

28

GENETIC ALGORITHM
Example
Find a number: 001010
Step 1. Chromosomes produced.
A) 010101
-1
B) 111101
-1
C) 011011
-4*
D) 101100
-3*
Best ones C & D

29

GENETIC ALGORITHM
Example
Find a number: 001010
C)
D)
C)
D)

Mating
New Variants
01:1011
01:1100 (E)
10:1100
10:1011 (F)
0110:11
0110:00 (G)
1011:00
1011:11 (H)

Selection of F & G

30

Evaluation
3
4*
4*
3

GENETIC ALGORITHM
Example
Mating
F)
1:01011
G)
0:11000
F)
101:011
G)
011:000

New Variants
1:11000 (H)
0:01011 (I)
101:000 (J)
011:011 (K)

Selection of I and J

31

Evaluation
3
5*
4*
4

GENETIC ALGORITHM
Example
I)
J)
I)
J)

Mating
0010:11
1010:00
00101:1
10100:0

New Variants
0010:00 (L)
1010:11 (M)
00101:0 (N)
10100:1 (O)

Evaluation
5
4
6 (success) *
3

In this game success was achieved after 16 questions, which is 4

times faster then checking all possible 26 = 64 combination

32

GENETIC ALGORITHM
Example
Mutation was not used in this example. Mutation would have
been necessary, if, e.g. there was a 0 in the third bit of all 3 initial
individuals. In that case no matter how the individuals are
combined, we can never change this bit into 1. Mutation takes
evolution out of a dead end.

33

Eight Queens Problem

The problem is to

place 8 queens on a
chess board so that
none of them can
attack the other. A
chess board can be
considered a plain
board with eight
columns and eight
rows.

Eight Queens Problem

The possible cells that

the Queen can move

to when placed in a
particular square are
shaded

Eight Queens Problem

We need a scheme to
denote the boards
position at any given
time

26834531

Eight Queens Problem

We need a scheme to
denote the boards
position at any given
time

26834531

Eight Queens Problem

Now we need a fitness function, a function by

which we can tell which board position is

nearer to our goal. Since we are going to
select best individuals at every step, we need
to define a method to rate these board
positions.

One fitness function can be to count the

number of Queens that do not attack others

Eight Queens Problem

Fitness
Q1 can
Q2 can
Q3 can
Q4 can
Q5 can
Q6 can
Q7 can
Q8 can

Function:
attack NONE
attack NONE
attack Q6
attack Q5
attack Q4
attack Q5
attack Q4
attack Q5

Fitness = No of. Queens that

can attack none
Fitness = 2

Eight Queens Problem

Choose initial population of board

configurations
Evaluate the fitness of each individual
(configuration)
Choose the best individuals from the
population for crossover

Eight Queens Problem

Suppose the following individuals are chosen for crossover

85727135

45827165

Eight Queens Problem

Using Crossover
Parents
Children

85727135

8572

45827165

4582

Eight Queens Problem

Eight Queens Problem

Mutation, flip bits at random
45827165
0100 0101 1000 0010 0111 0001 0110 0101
0100 0101 1000 0010 0111 0001 0011 0101
45827135

Eight Queens Problem

This process is repeated until an individual

with required fitness level is found. If no

such individual is found, then the process
is repeated further until the overall fitness
of the population or any of its individuals
gets very close to the required fitness
level. An upper limit on the number of
iterations is usually put to end the process
in finite time.

Eight Queens Problem

Solution!
Q
Q
Q
Q

8
Q
Q
Q
Q

46827135

GENETIC ALGORITHM

Selection Process

47

GENETIC ALGORITHM
Selection Process
It is used to select parents from the current population. The
selection is primarily based on the fitness. The better the
fitness of a chromosome, the greater its chance of being
selected to be a parent
The rate at which a selection algorithm selects individuals
with above average fitness is selective pressure
If there is not enough selective pressure, the population will
fail to converge upon a solution. If there is too much, the
population may not have enough diversity & converge
prematurely
48

GENETIC ALGORITHM
Selection Process: Random Selection
Random Selection:
Individuals are selected randomly with no reference to fitness
at all
All the individuals, good or bad, have an equal chance of
being selected

49

GENETIC ALGORITHM
Selection Process: Proportional Selection
Proportional Selection:
We can select the fittest chromosomes
However, the selection of only the fitter chromosomes may
result in the loss of a correct gene value which may be present
in a less fit member
One way to overcome this risk is to assign probability of
selection to each chromosome based on its fitness
In this way even the less fit members have some chance of
surviving into the next generation
50

GENETIC ALGORITHM

Selection Process: Proportional Selection

The probability of selection of a chromosome i may be
calculated as
pi = fitnessi / j fitnessj
Example
Chromosome
1
2
3
4

Fitness
7
4
2
1

Selection Probability
7/14
4/14
2/14
1/14

51

GENETIC ALGORITHM
Selection Process: Proportional Selection

52

GENETIC ALGORITHM
Selection Process: Proportional Selection
Chromosomes are selected based on their fitness relative to
the fitness of all other chromosomes
For this all the fitness are added to form a sum S and each
chromosome is assigned a relative fitness (which is its fitness
divided by the total fitness S)
A process similar to spinning a roulette wheel is adopted to
choose a parent; the better a chromosomes relative fitness,
the higher its chances of selection
53

GENETIC ALGORITHM
Selection Process: Proportional Selection
Once a parent is selected, the wheel is given a spin for finding
the second parent. If the same chromosome is selected as
the second parent, it is rejected and the wheel is spun
again
After finding a pair, a second pair is selected, and so on
A chromosome may get selected several times and appear as a
parent several times

54

GENETIC ALGORITHM
Selection Process: Proportional Selection
Advantage
Selective pressure varies with the distribution of fitness
within a population. If there is a lot of fitness difference
between the more fit and less fit chromosomes, then the
selective pressure will be higher
Disadvantage
As the population converges upon a solution, the selective
pressure decreases, which may hinder the GA to find
better solutions
55

GENETIC ALGORITHM

Selection Process: Tournament Selection

Tournament Selection:
One parent is selected by comparing a subset b of the
available chromosomes, and selecting the fittest; a second
parent may be selected by repeating the process
The selection pressure increases as b increases.
Value of b = 2 is most commonly used

56

GENETIC ALGORITHM

Selection Process: Tournament Selection

Its advantage is that the worse individuals of the population
will have very little probability of selection, whereas the
best individuals will not dominate the selection process,
thus ensuring diversity

57

GENETIC ALGORITHM
Selection Process: Rank based selection
Rank Based Selection:
Rank based selection uses the rank ordering of the fitness
values to determine the probability of selection and not the
fitness values themselves
This means that the selection probability is independent of
the actual fitness value
Ranking therefore has the advantage that a highly fit
individual will not dominate in the selection process as a
function of the magnitude of its fitness
58

GENETIC ALGORITHM

Selection Process: Rank based selection

The population is sorted from best to worst according to the
fitness
Each chromosome is then assigned a new
fitness based on a linear ranking function
New Fitness = (P r) + 1
where P = population size, r = fitness rank of the chromosome
If P = 11, then a chromosome of rank 1 will have a New
Fitness of 10 + 1 = 11 & a chromosome of rank 6 will have 6

59

GENETIC ALGORITHM
Selection Process: Rank based selection
A user adjusted slope can also be incorporated
New Fitness = {(P r) (max - min)/(P 1)} + min
where max and min are set by the user to determine the slope
(max - min)/(P 1) of the function
Let P = 11, max = 8, min = 3,
then a chromosome of rank 1 will have a New fitness of
10*5/10 + 3 = 8
& a chromosome of rank 6 will have 5*5/10 + 3 = 5.5
60

GENETIC ALGORITHM

Termination Requirement

61

GENETIC ALGORITHM
Termination Requirement
The GA continues until some termination requirement is met,
such as
- having a solution whose fitness exceeds some threshold
- pre-specified number of generations have evolved
- the fitness of solutions becomes stable & stops improving

62

GENETIC ALGORITHM

Population Size

63

GENETIC ALGORITHM

Population Size
Number of individuals present in an iteration (generation)
If the population size is too large, the processing time is high
and the GA tends to take longer to converge upon a
solution (because less fit members have to be selected to
make up the required population)
If the population size is too small, the GA is in danger of
premature convergence upon a sub-optimal solution (all
chromosomes will soon have identical traits). This is
primarily because there may not be enough diversity in
the population to allow the GA to escape local optima
64

Genetic Algorithms
Advantages of genetic algorithms:
Often outperform brute force approaches by
randomly jumping around the search space
Ideal for problem domains in which nearoptimal
(as opposed to exact) solutions are
adequate
Disadvantages of genetic algorithms:
Might not find any satisfactory partial solutions
Tuning can be a challenge