1.

Introduction
The aim of this tutorial is to explain genetic algorithms sufficiently for you to be
able to use them in your own projects. This is a stripped-down to-the-bareessentials type of tutorial. I'm not going to go into a great deal of depth and I'm
not going to scare those of you with math anxiety by throwing evil equations at
you every few sentences. In fact, I'm not going to throw any nasty equations at
you at all! Not in this particular tutorial anyway...
2.What Is the Genetic Algorithm?
The genetic algorithm is a method for solving both constrained and unconstrained
optimization problems that is based on natural selection, the process that drives
biological evolution. The genetic algorithm repeatedly modifies a population of
individual solutions. At each step, the genetic algorithm selects individuals at
random from the current population to be parents and uses them to produce the
children for the next generation. Over successive generations, the population
"evolves" toward an optimal solution. You can apply the genetic algorithm to
solve a variety of optimization problems that are not well suited for standard
optimization algorithms, including problems in which the objective function is
discontinuous, no differentiable, stochastic, or highly nonlinear. The genetic
algorithm can address problems of mixed integer programming, where some
components are restricted to be integer-valued.
The genetic algorithm uses three main types of rules at each step to create the
next generation from the current population:

Selection rules select the individuals, called parents that contribute to the
population at the next generation.

Crossover rules combine two parents to form children for the next
generation.

Mutation rules apply random changes to individual parents to form

children.

The genetic algorithm differs from a classical, derivative-based, optimization

algorithm in two main ways, as summarized in the following table.
Classical Algorithm

Genetic Algorithm

Generates a single point at each Generates a population of points at each

iteration. The sequence of points iteration. The best point in the population
approaches an optimal solution.
approaches an optimal solution.
Selects the next point in the Selects the next population by
sequence
by
a
deterministic computation which uses random number
computation.
generators.

3.Genetic Algorithm Terminology

3.1 Fitness Functions
The fitness function is the function you want to optimize. For standard
optimization algorithms, this is known as the objective function. The toolbox
software tries to find the minimum of the fitness function.
Write the fitness function as a file or anonymous function, and pass it as a
function handle input argument to the main genetic algorithm function.
3.2 Individuals
An individual is any point to which you can apply the fitness function. The value of
the fitness function for an individual is its score. For example, if the fitness
function is
f(x1,x2,x3)=(2x1+1)2+(3x2+4)2+(x32)2,
the vector (2, -3, 1), whose length is the number of variables in the problem, is an
individual. The score of the individual (2, 3, 1) is f(2, 3, 1) = 51.

An individual is sometimes referred to as a genome and the vector entries of an

individual as genes.
3.3 Populations and Generations
A population is an array of individuals. For example, if the size of the population is
100 and the number of variables in the fitness function is 3, you represent the
population by a 100-by-3 matrix. The same individual can appear more than once
in the population. For example, the individual (2, -3, 1) can appear in more than
one row of the array.
At each iteration, the genetic algorithm performs a series of computations on the
current population to produce a new population. Each successive population is
called a new generation.
3.4 Diversity
Diversity refers to the average distance between individuals in a population. A
population has high diversity if the average distance is large; otherwise it has low
diversity. In the following figure, the population on the left has high diversity,
while the population on the right has low diversity.

Diversity is essential to the genetic algorithm because it enables the algorithm to

search a larger region of the space.

3.5 Fitness Values and Best Fitness Values

The fitness value of an individual is the value of the fitness function for that
individual. Because the toolbox software finds the minimum of the fitness
function, the best fitness value for a population is the smallest fitness value for
any individual in the population.
3.6 Parents and Children
To create the next generation, the genetic algorithm selects certain individuals in
the current population, called parents, and uses them to create individuals in the
next generation, called children. Typically, the algorithm is more likely to select
parents that have better fitness values.
4 . How the Genetic Algorithm Works
4.1 Outline of the Algorithm
The following outline summarizes how the genetic algorithm works:
1. The algorithm begins by creating a random initial population.
2. The algorithm then creates a sequence of new populations. At each step,
the algorithm uses the individuals in the current generation to create the
next population. To create the new population, the algorithm performs the
following steps:
a.
Scores each member of the current population by computing its fitness
value.
b.
Scales the raw fitness scores to convert them into a more usable range of
values.
c.

Selects members, called parents, based on their fitness.

d.
Some of the individuals in the current population that have lower fitness
are chosen as elite. These elite individuals are passed to the next population.

e.
Produces children from the parents. Children are produced either by
making random changes to a single parentmutationor by combining the
vector entries of a pair of parentscrossover.
f.
Replaces the current population with the children to form the next
generation.
The algorithm stops when one of the stopping criteria is met.
4.2 Initial Population
The algorithm begins by creating a random initial population, as shown in the
following figure.

In this example, the initial population contains 20 individuals, which is the default
value of Population size in thePopulation options. Note that all the individuals in
the initial population lie in the upper-right quadrant of the picture, that is, their
coordinates lie between 0 and 1, because the default value of Initial range in
the Population options is [0;1].
If you know approximately where the minimal point for a function lies, you should
set Initial range so that the point lies near the middle of that range. For example,
if you believe that the minimal point for Rastrigin's function is near the point [0 0],
you could set Initial range to be [-1;1]. However, as this example shows, the
5

genetic algorithm can find the minimum even with a less than optimal choice
for Initial range.
4.3 Creating the Next Generation
At each step, the genetic algorithm uses the current population to create the
children that make up the next generation. The algorithm selects a group of
individuals in the current population, called parents, who contribute their genes
the entries of their vectorsto their children. The algorithm usually selects
individuals that have better fitness values as parents. You can specify the function
that the algorithm uses to select the parents in the Selection function field in the
Selection options.
The genetic algorithm creates three types of children for the next generation:

Elite children are the individuals in the current generation with the best
fitness values. These individuals automatically survive to the next
generation.

Crossover children are created by combining the vectors of a pair of

parents.

Mutation children are created by introducing random changes, or

mutations, to a single parent.

The following schematic diagram illustrates the three types of children.

Mutation and Crossover explains how to specify the number of children of each
type that the algorithm generates and the functions it uses to perform crossover
and mutation.
The following sections explain how the algorithm creates crossover and mutation
children.
4.4 Crossover Children
The algorithm creates crossover children by combining pairs of parents in the
current population. At each coordinate of the child vector, the default crossover
function randomly selects an entry, or gene, at the same coordinate from one of
the two parents and assigns it to the child. For problems with linear constraints,
the default crossover function creates the child as a random weighted average of
the parents.
4.5 Mutation Children
The algorithm creates mutation children by randomly changing the genes of
individual parents. By default, for unconstrained problems the algorithm adds a
random vector from a Gaussian distribution to the parent. For bounded or linearly
constrained problems, the child remains feasible.
The following figure shows the children of the initial population, that is, the
population at the second generation, and indicates whether they are elite,
crossover, or mutation children.

4.6 Plots of Later Generations

The following figure shows the populations at iterations 60, 80, 95, and 100.

As the number of generations increases, the individuals in the population get

closer together and approach the minimum point [0 0].
5 Stopping Conditions for the Algorithm
The genetic algorithm uses the following conditions to determine when to stop:

Generations The algorithm stops when the number of generations

reaches the value of Generations.

Time limit The algorithm stops after running for an amount of time in
seconds equal to Time limit.

Fitness limit The algorithm stops when the value of the fitness function
for the best point in the current population is less than or equal to Fitness
limit.

Stall generations The algorithm stops when the average relative change
in the fitness function value over Stall generations is less than Function
tolerance.

Stall time limit The algorithm stops if there is no improvement in the

objective function during an interval of time in seconds equal to Stall time
limit.

Stall test The stall condition is either average change or geometric

weighted. For geometric weighted, the weighting function is 1/2n,
where n is the number of generations prior to the current. Both stall
conditions apply to the relative change in the fitness function over Stall
generations.

Function Tolerance The algorithm runs until the average relative change
in the fitness function value over Stall generations is less than Function
tolerance.

Nonlinear constraint tolerance The Nonlinear constraint tolerance is not

used as stopping criterion. It is used to determine the feasibility with
respect to nonlinear constraints. Also, a point is feasible with respect to
linear constraints when the constraint violation is below the square root
of Nonlinear constraint tolerance.

The algorithm stops as soon as any one of these conditions is met. You can specify
the values of these criteria in theStopping criteria pane in the Optimization app.
The default values are shown in the pane.

10

When you run the genetic algorithm, the Run solver and view results panel
displays the criterion that caused the algorithm to stop.
The options Stall time limit and Time limit prevent the algorithm from running too
long. If the algorithm stops due to one of these conditions, you might improve
your results by increasing the values of Stall time limit and Time limit.
5.1 Selection
The selection
ion function chooses parents for the next generation based on their
scaled values from the fitness scaling function. An individual can be selected more
than once as a parent, in which case it contributes its genes to more than one
child. The default selection
ion option, Stochastic uniform, lays out a line in which
each parent corresponds to a section of the line of length proportional to its
scaled value. The algorithm moves along the line in steps of equal size. At each
step, the algorithm allocates a parent from the section it lands on.
11

A more deterministic selection option is Remainder, which performs two steps:

In the first step, the function selects parents deterministically according to

the integer part of the scaled value for each individual. For example, if an
individual's scaled value is 2.3, the function selects that individual twice as a
parent.

In the second step, the selection function selects additional parents using
the fractional parts of the scaled values, as in stochastic uniform selection.
The function lays out a line in sections, whose lengths are proportional to
the fractional part of the scaled value of the individuals, and moves along
the line in equal steps to select the parents.

Note that if the fractional parts of the scaled values all equal 0, as can occur
using top scaling, the selection is entirely deterministic.
5.2 Reproduction Options
Reproduction options control how the genetic algorithm creates the next
generation. The options are

Elite count the number of individuals with the best fitness values in the
current generation that are guaranteed to survive to the next generation.
These individuals are called elite children. The default value of Elite
count is 2.

When Elite count is at least 1, the best fitness value can only decrease from one
generation to the next. This is what you want to happen, since the genetic
algorithm minimizes the fitness function. Setting Elite count to a high value causes
the fittest individuals to dominate the population, which can make the search less
effective.

Crossover fraction The fraction of individuals in the next generation,

other than elite children, that are created by crossover. Setting the
Crossover Fraction describes how the value of Crossover fraction affects
the performance of the genetic algorithm.
12

5.3 Mutation and Crossover

The genetic algorithm uses the individuals in the current generation to create the
children that make up the next generation. Besides elite children, which
correspond to the individuals in the current generation with the best fitness
values, the algorithm creates

Crossover children by selecting vector entries, or genes, from a pair of

individuals in the current generation and combines them to form a child

Mutation children by applying random changes to a single individual in the

current generation to create a child

Both processes are essential to the genetic algorithm. Crossover enables the
algorithm to extract the best genes from different individuals and recombine
them into potentially superior children. Mutation adds to the diversity of a
population and thereby increases the likelihood that the algorithm will generate
individuals with better fitness values.
You can specify how many of each type of children the algorithm creates as
follows:

Elite count, in Reproduction options, specifies the number of elite children.

Crossover fraction, in Reproduction options, specifies the fraction of the

population, other than elite children, that are crossover children.

For example, if the Population size is 20, the Elite count is 2, and the Crossover
fraction is 0.8, the numbers of each type of children in the next generation are as
follows:

There are two elite children.

There are 18 individuals other than elite children, so the algorithm rounds
0.8*18 = 14.4 to 14 to get the number of crossover children.

The remaining four individuals, other than elite children, are mutation
children.
13

6. Biology Lesson
Every organism has a set of rules, a blueprint so to speak, describing how that
organism is built up from the tiny building blocks of life. These rules are encoded
in the genes of an organism, which in turn are connected together into long
strings called chromosomes. Each gene represents a specific trait of the organism,
like eye colour or hair colour, and has several different settings. For example, the
settings for a hair colour gene may be blonde, black or auburn. These genes and
their settings are usually referred to as an organism's genotype. The physical
expression of the genotype - the organism itself - is called the phenotype.

When two organisms mate they share their genes. The resultant offspring may
end up having half the genes from one parent and half from the other. This
process is called recombination. Very occasionally a gene may be mutated.
Normally this mutated gene will not affect the development of the phenotype but
very occasionally it will be expressed in the organism as a completely new trait.

Life on earth has evolved to be as it is through the processes of natural selection,

recombination and mutation. To illustrate how these processes work together to
produce the diverse range of flora and fauna we share our planet with let me tell
you a little story....

Once upon a time there lived a species of creatures called Hooters. Hooters had
evolved entirely within the darkened confines of a vast cave system hidden deep in
the bowels of a mountain range. They'd had an easy life, feeling and smelling
around the damp cave walls for the algae they so loved to eat, oozing between
rocks and, at mating time, listening intently for the hoots of other Hooters. There
were no predators in the caves, it was just the Hooters, the algae and the
occasional friendly slug, so the Hooters never had anything to fear (except for
maybe the occasional bad tempered Hooter). An underground river flowed
14

through the cave system and water continuously dripped down through the water
table bringing with it the fresh nutrients the algae thrived on so there was always
plenty to eat and drink. However, although Hooters could feel and hear well they
never had any need for eyes in the pitch blackness of the caves and as a result
were totally blind. This never seemed to concern any of the Hooters though and
they all had a whale of a time munching away and hooting in the darkness.

Then one day an earthquake caused part of the cave system to collapse and for
the first time in many millennia the Hooters felt the warmth of sunlight upon their
skin and the soft springiness of moss beneath their feet. A few daring Hooters
tasted the moss and found that it was even better eating than the cave algae.
"Ooooooooooh!" they hooted between mouthfuls of moss and promptly got
gobbled up by the marauding eagles who had flown in to see what all the
commotion was about.

For a while it looked as though the Hooters may be hunted to extinction, for
although they liked to eat the moss they could never tell if an eagle was flying
above. Not only that, they couldn't even tell if they were concealed beneath a rock
or not unless it was low enough to reach for with their feelers. Every day many
Hooters would stumble out from the caves with the sweet smell of moss in their
nostrils only to be swiftly carried away and eaten by an eagle. Their situation
seemed grim indeed.

Fortunately, over the years, the population of Hooters had grown to be enormous
in the safety of the caves and enough of them were surviving to mate - after all,
an eagle can only eat so much. One day, a brood of Hooters was born that shared
a mutated skin cell gene. This particular gene was responsible for the development
of the skin cells on their foreheads. During the development of the baby Hooters,
when their skin cells grew from the mutated gene instructions they were slightly
light sensitive. Each new baby Hooter could sense if something was blocking the
15

light to its forehead or not. When these little baby Hooters grew up into bigger
Hooters and ventured into the light to eat the moss they could tell if something
was swooping overhead or not. So these Hooters grew up to have a slightly better
chance of survival than their totally blind cousins. And because they had a better
chance of survival, they reproduced much more, therefore passing the new light
sensitive skin cell gene to their offspring. After a very short while the population
became dominated by the Hooters with this slight advantage.

Now let's zip a few thousand generations into the future. If you extrapolate this
process over very many years and involving lots of tiny mutations occurring in the
skin cell genes it's easy to imagine a process where one light sensitive cell may
become a clump of light sensitive cells, and then how the interior cells of the
clump may mutate to harden into a tiny lens shaped area, which would help to
gather the light and focus it into one place. It's not too difficult to envision a
mutation that gives rise to two of these light gathering areas thereby bestowing
binocular vision upon the Hooters. This would be a huge advantage over their
Cyclopsian cousins as the Hooters would now be able to judge distances
accurately and have a greater field of view.

As you can see the processes of natural selection - survival of the fittest - and
gene mutation have very powerful roles to play in the evolution of an organism.
But how does recombination fit into the scheme of things? Well to show you that
I need to tell about some other Hooters...

At around the same time the Hooters with the light sensitive cells were frolicking
around in the moss and teasing the eagles, another brood of Hooters had been
born who shared a mutated gene that affected their hooter. This mutation gave
rise to a slightly bigger hooter than their cousins, and because it was bigger they
could now hoot over longer distances. This turned out to be useful in the rapidly
diminishing population because the Hooters with the bigger hooters could call out
16

to potential mates situated far away. Not only that but the female Hooters began
to show a slight preference to males with larger hooters . The upshot of this of
course was that the better endowed Hooters stood a much better chance of
mating than any not so well off Hooters. Over a period of time, large hooters
became prevalent in the population.

Then one fine day a female Hooter with the gene for light sensitive skin cells met a
male Hooter with the gene for producing huge hooters. They fell in love, and
shortly afterwards produced a brood of lovely baby Hooters. Now, because the
babies chromosomes were a recombination of both parents chromosomes, some
of the babies shared both the special genes and grew up not only to have light
sensitive skin cells, but huge hooters too! These new offspring were extremely
good at avoiding the eagles and reproducing so the process of evolution began to
favour them and once again this new improved type of Hooter became dominant
in the population.

And so on. And so on...

Genetic Algorithms are a way of solving problems by mimicking the same

processes mother nature uses. They use the same combination of selection,
recombination and mutation to evolve a solution to a problem. Neat huh? Turn
the page to find out exactly how it's done.
6.1 The Genetic Algorithm - a brief overview

Before you can use a genetic algorithm to solve a problem, a way must be found
of encoding any potential solution to the problem. This could be as a string of real
numbers or, as is more typically the case, a binary bit string. I will refer to this bit
string from now on as the chromosome. A typical chromosome may look like this:
17

10010101110101001010011101101110111111101

(Don't worry if none of this is making sense to you at the moment, it will all start
to become clear shortly. For now, just relax and go with the flow.)
At the beginning of a run of a genetic algorithm a large population
of random chromosomes is created. Each one, when decoded will represent a
different solution to the problem at hand. Let's say there are N chromosomes in
the initial population. Then, the following steps are repeated until a solution is
found

Test each chromosome to see how good it is at solving the problem at hand
and assign a fitness score accordingly. The fitness score is a measure of how
good that chromosome is at solving the problem to hand.

Select two members from the current population. The chance of being
selected is proportional to the chromosomes fitness. Roulette
wheel selection is a commonly used method.

Dependent on the crossover rate crossover the bits from each chosen
chromosome at a randomly chosen point.

Step through the chosen chromosomes bits and flip dependent on

the mutation rate.

Repeat step 2, 3, 4 until a new population of N members has been created.

6.2 Tell me about Roulette Wheel selection

This is a way of choosing members from the population of chromosomes in a way

that is proportional to their fitness. It does not guarantee that the fittest member

18

goes through to the next generation merely that it has a very good chance of
doing so. It works like this:

Imagine that the populations total fitness score is represented by a pie chart, or
roulette wheel. Now you assign a slice of the wheel to each member of the
population. The size of the slice is proportional to that chromosomes fitness
score. i.e. the fitter a member is the bigger the slice of pie it gets. Now, to choose
a chromosome all you have to do is spin the ball and grab the chromosome at the
point it stops.

6.3 What's the Crossover Rate?

This is simply the chance that two chromosomes will swap their bits. A good value
for this is around 0.7. Crossover is performed by selecting a random gene along
the length of the chromosomes and swapping all the genes after that point.

e.g. Given two chromosomes

10001001110010010
01010001001000011

Choose a random bit along the length, say at position 9, and swap all the bits after
that point

so the above become:

19

10001001101000011
01010001010010010

6.4 What's the Mutation Rate?

This is the chance that a bit within a chromosome will be flipped (0 becomes 1, 1
becomes 0). This is usually a very low value for binary encoded genes, say 0.001

So whenever chromosomes are chosen from the population the algorithm first
checks to see if crossover should be applied and then the algorithm iterates down
the length of each chromosome mutating the bits if applicable.
6.5 From Theory to Practice

To hammer home the theory you've just learnt let's look at a simple problem:

Given the digits 0 through 9 and the operators +, -, * and /, find a sequence that
will represent a given target number. The operators will be applied sequentially
from left to right as you read.

So, given the target number 23, the sequence 6+5*4/2+1 would be one possible
solution.

20

If 75.5 is the chosen number then 5/2+9*7-5 would be a possible solution.

Please make sure you understand the problem before moving on. I know it's a
little contrived but I've used it because it's very simple.

Stage 1: Encoding

First we need to encode a possible solution as a string of bits a chromosome. So

how do we do this? Well, first we need to represent all the different characters
available to the solution... that is 0 through 9 and +, -, * and /. This will represent
a gene. Each chromosome will be made up of several genes.

Four bits are required to represent the range of characters used:

0:

0000

1:

0001

2:

0010

3:

0011

4:

0100

5:

0101

6:

0110

7:

0111
21

8:

1000

9:

1001

+:

1010

-:

1011

*:

1100

/:

1101

The above show all the different genes required to encode the problem as
described. The possible genes 1110 & 1111 will remain unused and will be
ignored by the algorithm if encountered.

So now you can see that the solution mentioned above for 23, ' 6+5*4/2+1' would
be represented by nine genes like so:

0110 1010 0101 1100 0100 1101 0010 1010 0001

These genes are all strung together to form the chromosome:

011010100101110001001101001010100001

6.6 A Quick Word about Decoding

22

Because the algorithm deals with random arrangements of bits it is often going to
come across a string of bits like this:

0010001010101110101101110010

Decoded, these bits represent:

0010 0010 1010 1110 1011 0111 0010

n/a

Which is meaningless in the context of this problem! Therefore, when decoding,

the algorithm will just ignore any genes which dont conform to the expected
pattern of: number -> operator -> number -> operator and so on. With this in
mind the above nonsense chromosome is read (and tested) as:

2 + 7

Stage 2: Deciding on a Fitness Function

23

This can be the most difficult part of the algorithm to figure out. It really depends
on what problem you are trying to solve but the general idea is to give a higher
fitness score the closer a chromosome comes to solving the problem. With
regards to the simple project I'm describing here, a fitness score can be assigned
that's inversely proportional to the difference between the solution and the value
a decoded chromosome represents.

If we assume the target number for the remainder of the tutorial is 42, the
chromosome mentioned above

011010100101110001001101001010100001

has a fitness score of 1/(42-23) or 1/19.

As it stands, if a solution is found, a divide by zero error would occur as the fitness
would be 1/(42-42). This is not a problem however as we have found what we
were looking for... a solution. Therefore a test can be made for this occurrence
and the algorithm halted accordingly.

Stage 3: Getting down to business

First, please read this tutorial again.

24

If you now feel you understand enough to solve this problem I would recommend
trying to code the genetic algorithm yourself. There is no better way of learning.
If, however, you are still confused, I have already prepared some simple code
which you can find here. Please tinker around with the mutation rate, crossover
rate, size of chromosome etc to get a feel for how each parameter effects the
algorithm. Hopefully the code should be documented well enough for you to
follow what is going on! If not please email me and Ill try to improve the
commenting.

Note: The code given will parse a chromosome bit string into the values we have
discussed and it will attempt to find a solution which uses all the valid symbols it
has found. Therefore if the target is 42, + 6 * 7 / 2 would not give a positive result
even though the first four symbols("+ 6 * 7") do give a valid solution.

(Delphi code submitted by Asbjrn can be found here and Java code submitted by
Tim Roberts can be found here)

Last Words

I hope this tutorial has helped you get to grips with the basics of genetic
algorithms. Please note that I have only covered the very basics here. If you have
found genetic algorithms interesting then there is much more for you to learn.
There are different selection techniques to use, different crossover and mutation
operators to try and more esoteric stuff like fitness sharing and speciation to fool
around with. All or some of these techniques will improve the performance of
your genetic algorithms considerably.

25

Stuff to Try

If you have succeeded in coding a genetic algorithm to solve the problem given in
the tutorial, try having a go at the following more difficult problem:

Given an area that has a number of non overlapping disks scattered about its
surface as shown in Screenshot 1,

Screenshot 1

Use a genetic algorithm to find the disk of largest radius which may be placed
amongst these disks without overlapping any of them. See Screenshot 2.
26

Screenshot 2

7 Example: Minimize Rastrigin's Function

7.1 Rastrigin's Function
This section presents an example that shows how to find the minimum of
Rastrigin's function, a function that is often used to test the genetic algorithm.
For two independent variables, Rastrigin's function is defined as
Ras(x)=20+x21+x2210(cos2x1+cos2x2).
Global Optimization Toolbox software contains the rastriginsfcn.m file,
which computes the values of Rastrigin's function. The following figure shows a
plot of Rastrigin's function.

27

As the plot shows, Rastrigin's function has many local minimathe "valleys" in
the plot. However, the function has just one global minimum, which occurs at the
point [0 0] in the x-y plane, as indicated by the vertical line in the plot, where the
value of the function is 0. At any local minimum other than [0 0], the value of
Rastrigin's function is greater than 0. The farther the local minimum is from the
origin, the larger the value of the function is at that point.
Rastrigin's function is often used to test the genetic algorithm, because its many
local minima make it difficult for standard, gradient-based methods to find the
global minimum.
The following contour plot of Rastrigin's function shows the alternating maxima
and minima.

28

7.2 Finding the Minimum of Rastrigin's Function

This section explains how to find the minimum of Rastrigi
Rastrigin's
n's function using the
genetic algorithm.
Note Because the genetic algorithm uses random number generators, the
algorithm returns slightly different results each time you run it.
To find the minimum, do the following steps:
1. Enter optimtool('ga') at the command line to open the Optimization app.
2. Enter the following in the Optimization app:
In the Fitness function field, enter @rastriginsfcn.
In the Number of variables field, enter 2,, the number of independent variables
for Rastrigin's function.
The Fitness function and Number of variables fields should appear as shown
in the following figure.

3. Click the Start button in the Run solver and view results pane, as shown in
the following figure.
29

While the algorithm is running, the Current iteration field displays the number
of the current generation. You can temporarily pause the algorithm by clicking
the Pause button. When you do so, the button name changes toResume.
to
To
resume the algorithm from the point at which you paused it, click Resume.
When the
he algorithm is finished, the Run solver and view results pane appears
as shown in the following figure. Your numerical results might differ from
those in the figure, since ga is stochastic.

The display shows:

The final value of the fitness function when the algorithm terminated:
Objective function value: 5.550533778020394E
5.550533778020394E-4
Note that the value shown is very close to the actual minimum value of
Rastrigin's function, which is 0. Setting the Initial Range, Setting the Amount of
Mutation, and Set Maximum Number of Generations describe some ways to get
a result that is closer to the actual minimum.
The reason the algorithm terminated.
Optimization terminated: maximum number of generations exceeded.

The final point, which in this example is [-0.002 -0.001].

7.3 Finding the Minimum from the Command Line
To find the minimum of Rastrigin's function from the command line, enter

rng(1,'twister') % for rep

reproducibility
[x fval exitflag] = ga(@rastriginsfcn, 2)
30

This returns
Optimization terminated:
average change in the fitness value less than options.TolFun.
x=
-0.0017 -0.0185
fval =
0.0682
exitflag =
1

x is the final point returned by the algorithm.

fval is the fitness function value at the final point.
exitflag is integer value corresponding to the reason that the algorithm
terminated.
Note: Because the genetic algorithm uses random number generators, the
algorithm returns slightly different results each time you run it.
7.4 Displaying Plots
The Optimization app Plot functions pane enables you to display various plots that
provide information about the genetic algorithm while it is running. This
information can help you change options to improve the performance of the
algorithm. For example, to plot the best and mean values of the fitness function at
each generation, select the box next to Best fitness, as shown in the following
figure.

31

When you click Start,, the Optimization app display

displayss a plot of the best and mean
values of the fitness function at each generation.
Try this on Minimize Rastrigin's Function:

When the algorithm stops, the plot appears as sho

shown
wn in the following figure.

The points at the bottom of the plot denote the best fitness values, while the points
above them denote the averages of the fitness values in each generation. The plot
32

also displays the best and mean values in the current generation numerically at the
top.
To get a better picture of how much the best fitness values are decreasing, you can
change the scaling of the y-axis in the plot to logarithmic scaling. To do so,
1. Select Axes Properties from the Edit menu in the plot window to open the
Property Editor attached to your figure window as shown below.

2. Click the Y Axis tab.

3. In the Y Scale pane, select Log.
The plot now appears as shown in the following figure.

Typically, the best fitness value improves rapidly in the early generations, when
the individuals are farther from the optimum. The best fitness value improves
more slowly in later generations, whose populations are closer to the optimal
point.
33

REFERENBCE
1. Deb, K., Gupta, S., Daum, D., Branke, J., Mall, A., and Padmanabhan, D.
(2009). Reliability-Based Optimization Using Evolutionary Algorithms. IEEE
Transacations on Evolutionary Computation.
2. Mittal, S. and Deb, K. (2009). Optimal strategies of the iterated prisoners
dilemma problem for multiple conflicting objectives. IEEE Transactions on
Evolutionary Computation, 13(3), 554565.
3. Pettersson, F., Saxen, H. and Deb, K. (2009). Genetic algorthm based
multicriteria optimization of ironmaking in the blast furnace. Journal of
Materials and Manufacturing Processes, 24, 17.
4. Deb, K. (2008). Scope of stationary multi-objective evolutionary
optimization: A case study on a hydro-thermal power dispatch
problem. Journal of Global Optimization, 41(4), 479515.
5. Dyer, J. S., Fishburn, P. C., Steuer, R. E., Wallenius, J., Zionts, S. and Deb,
K. (2008). Multiple criteria decision making, multiattribute utility theory:
Recent accomplishments and what lies ahead.Management Science, 54(7),
13361349.
6. http://in.mathworks.com/help/gads/example-rastrigins-function.html

34