Genetic Algorithms

An algorithm is a set of instructions that

is repeated to solve a problem.
A genetic algorithm conceptually follows
steps inspired by the biological
processes of evolution.
Genetic Algorithms follow the idea of
SURVIVAL OF THE FITTEST- Better
and better solutions evolve from
previous generations until a near optimal
solution is obtained.

Genetic Algorithms
Also known as evolutionary algorithms,
genetic algorithms demonstrate self
organization and adaptation similar to the
way that the fittest biological organism
survive and reproduce.
A genetic algorithm is an iterative procedure
that represents its candidate solutions as
strings of genes called chromosomes.

Generally applied to spaces which are

too large

Genetic Algorithms

Genetic Algorithms are often used to

improve the performance of other AI
methods such as expert systems or
neural networks.
The method learns by producing
offspring that are better and better as
measured by a fitness function, which is
a measure of the objective to be
obtained (maximum or minimum).

Simple GA
initialize population;
evaluate population;
while TerminationCriteriaNotSatisfied
{
select parents for reproduction;
perform crossover and mutation; Every loop called
repair();
generation
evaluate population;
}

Concepts

Population:set of individuals each

representing a possible solution to a given
problem.
Gene:a solution to problem represented as
a set of parameters ,these parameters
known as genes.
Chromosome:genes joined together to
form a string of values called chromosome.
Fitness score(value):every chromosome
has fitness score can be inferred from the
chromosome itself by using fitness function.

Stochastic operators

Selection replicates the most successful

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

Simulated Evolution
We

need the following

Representation of an individual
Fitness Function
Reproduction Method
Selection Criteria

Representing an Individual
An

individual is data structure

representing the genetic
structure of a possible solution.
Genetic structure consists of an
alphabet (usually 0,1)

Binary Encoding

Most Common string of bits, 0 or 1.

Chrom: A = 1 0 11 0 0 1 0 1 1
Chrom: B = 1 1 1 1 1 1 0 0 0 0
Gives you many possibilities
Example Problem: Knapsack problem
The problem: there are things with given value
and size. The knapsack has given capacity.
Select things to maximize the values.
Encoding: Each bit says, if the corresponding
thing is in the knapsack

Permutation Encoding
Used in ordering problems
Every chromosome is a string of numbers,
which represents number is a sequence.

Chrom A: 1 5 3 2 6 4 7 9 8
Chrom B: 8 5 7 7 2 3 1 4 9

Example: Travelling salesman problem

The problem: cities that must be visited.
Encoding says order of cities in which
salesman willl visit.

Another Example
To

find optimal quantity of three

major ingredients (sugar, milk,
sesame oil) denoting ounces.
Use an alphabet of 1-9 denoting
ounces..
Solutions might be 1-1-1, 2-1-4, 3-3-1.

Value Encoding

Used for complicated values (real numbers)

and when binary coding would be difficult
Each chromosome is a string of some values.
Chrom A: 1.2323 5.3243 0.4556
Chrom B: abcdjeifjdhdierjfd
Chrom C: (back), (back), (right), (forward), (left)

Example: Finding weights for neural nets.

The problem: find weights for network
Encoding: Real values that represent weights

Rule base system

Given a rule (if color=red and size=small
and shape=round then object=apple.
Assume that each feature has finite set of
values (e.g., size = small,large)
Represent the value as a substring of length
equl to the number of possible values. For
example, small = 10, large = 01.
The entire rule would be 100 10 01 0100
set of rules concatenating the values
together.

How offspring are

produced Reproduction- Through
Reproduction

reproduction, genetic algorithms

produce new generations of
improved solutions by selecting
parents with higher fitness ratings
or by giving such parents a greater
probability of being contributors
and by using random selection

How offspring are

produced

(Recombination) Crossover- Many

genetic algorithms use strings of binary
symbols for chromosomes, as in our
Knapsack example, to represent solutions.
Crossover means choosing a random
position in the string (say, after 2 digits)
and exchanging the segments either to
the right or to the left of this point with
another string partitioned similarly to
produce two new off spring.

Crossover Example
Parent

A 011011
Parent B 101100
Mate the parents by splitting each
number as shown between the second
and third digits (position is randomly
selected)
01*1011
10*1100

Crossover Example

Now combine the first digits of A with the last

digits of B, and the first digits of B with the last
digits of A
This gives you two new offspring

011100
101011

If these new solutions, or offspring, are better

solutions than the parent solutions, the system will
keep these as more optimal solutions and they will
become parents. This is repeated until some
condition (for example number of populations or
improvement of the best solution) is satisfied.

How offspring are

produced
Mutation-

Mutation is an arbitrary
change in a situation. Sometimes it
is used to prevent the algorithm
from getting stuck. The procedure
changes a 1 to a 0 to a 1 instead of
duplicating them. This change
occurs with a very low probability
(say 1 in 1000)

Genetic Algorithm
Operators
Mutation and Crossover
Parent 1

1 0 1 0 1 1 1

Parent 2

1 1 0 0 0 1 1

Child 1

1 0 1 0 0 1 1

Child 2

1 1 0 0 1 1 0

Mutation

Crossover Operators

Singlepoint
point crossover:
Parent A: 1 0 0 1 0| 1 1 1 0 1
Parent B: 0 1 0 1 1 |1 0 1 1 0
Child AB: 1 0 0 1 0 1 0 1 1 0
Child BA: 0 1 0 1 1 1 1 1 0 1
Twopoint
point crossover:
Parent A: 1 0 0|1 0 1 1| 1 0 1
Parent B: 0 1 0* 1 1 1 0* 1 1 0
Child AB: 1 0 0 1 1 1 0 1 0 1
Child BA: 0 1 0 1 0 1 1 1 1 0

Uniform Crossover and

- A random mask is generated
- The mask determines which bits are copied from
one parent and which from the other parent
- Bit density in mask determines how much material
is taken from the other parent.

Examples
Mutation:

The recipe example:

1-2-3 may be changed to 1-3-3 or 3-23, giving two new offspring. How
often? How many digits change? How
big? (parameters to adjust)

More examples:
Crossover

Recipe :
Parents 1-3-3 & 3-2-3. Crossover
point after the first digit. Generate
two offspring: 3-3-3 and 1-2-3.
Can have one or two point crossover.

Crossover Permutation
Encoding
Single point crossover - one crossover point is selected,
till this point the permutation is copied from the first
parent, then the second parent is scanned and if the
number is not yet in the offspring it is added
(1 2 3 4 5| 6 7 8 9) + (4 5 3 6 8| 9 7 2 1) = (1 2 3 4 5 6 8 9 7)

Mutation
Order changing - two numbers are selected and
exchanged
(1 2 3 4 5 6 8 9 7) => (1 8 3 4 5 6 2 9 7)

Crossover Value
Encoding
Crossover
All crossovers from binary encoding can
be used
Mutation
Adding a small number (for real value encoding)
- to selected values is added (or subtracted) a
small number

(1.29 5.68 2.86 4.11 5.55) => (1.29 5.68 2.73 4.22
5.55)

Selection Criteria

Fitness proportionate selection, rank

selection methods.

Fitness proportionate each individual, I, has

the probability
fitness(I)/sum_over_all_individual_j Fitness(j ),
where Fitness(I) is the fitness function value for
individual I.
Rank selection sorts individual by fitness and
the probability that an individual will be
selected is proportional to its rank in this sorted
list.

Fitness Function

Represents a rank of the representation

It is usually a real number.
The function usually has a value between 0
and 1 and is monotonically increasing.
One can have a subjective judgment (e.g.
1-5 for recipe 2-1-4.)
Similarly the length of the route in the
traveling salesperson problem is a good
measure, because the shorter the route,
the better the solution.

Outline of the Basic Genetic

Algorithm

[Start] Generate random

population of n chromosomes
(suitable solutions for the problem)
[Fitness] Evaluate the fitness f(x)
of each chromosome x in the
population
[New population] Create a new
population by repeating following
steps until the new population is
complete

Outline of the Basic Genetic

Algorithm
4.

5.

6.

[Selection] Select two parent chromosomes

from a population according to their fitness (the
better fitness, the bigger chance to be selected)
The idea is to choose the better parents.
[Crossover] With a crossover probability cross
over the parents to form a new offspring
(children). If no crossover was performed,
offspring is an exact copy of parents.
[Mutation] With a mutation probability mutate
new offspring at each locus (position in
chromosome).

Outline of the Basic Genetic

Algorithm
[Accepting] Place new offspring in a new
population
8. [Replace] Use new generated population
for a further run of algorithm
9. [Test] If the end condition is satisfied,
stop, and return the best solution in
current population
10. [Loop] Go to step 2
7.

Flow Diagram of the

Genetic Algorithm
Process
Describe
Problem

Generate
Initial
Solutions

Step 1

Test: is initial
solution good enough?

No
Step 2

Step 3
Step 4
Step 5

Select parents
to reproduce

Apply crossover process

and create a set of offspring
Apply random mutation

Yes

Stop

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

Representation (encoding)
Possible individuals encoding

Bit strings
1100)
Real numbers
89.2)
Permutations of element
E15)
Lists of rules
R23)
Program elements
programming)

(0101 ...
(43.2 -33.1 ... 0.0
(E11 E3 E7 ... E1
(R1 R2 R3 ... R22
(genetic

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

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

Selection

Fitness Proportionate Selection

Derived by Holland as the optimal tradeoff between exploration and exploitation

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

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
p(i )

1
i 1

2
(

1
)
,1 2

n
n 1

where can be interpreted as

the expected sampling rate of
the best individual

Tournament Selection
Tournament Selection:
randomlyselecttwoindividualsandtheone
withthehighestrankgoesonandreproduces
caresonlyabouttheonewiththehigherrank,
notthespreadbetweenthetwofitnessscores
putsanupperandlowerboundonthechances
thatanyindividualtoreproduceforthenext
generationequalto:(2s 2r + 1) / s2
s isthesizeofthepopulation
r istherankofthe"winning"individual
canbegeneralizedtoselectbestofnindividuals

Recombination (Crossover)
* Enables the evolutionary process
to move toward promising
regions of the search space
* Matches good parents sub-solutions
to construct better offspring

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

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

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

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`

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

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

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

as many times as the
number of individuals we
need to have the same
parent population size
(6 in our case)

2
3

Areais
Proportional
tofitness
value

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)

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

Example (crossover2)
Before crossover:
s1`=1111010101
s2`=1110110101

s5`=0100010011
s6`=1110111101

After crossover:
s1``=1110110101
s2``=1111010101

s5``=0100011101
s6``=1110110011

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

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

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

Example :
Suppose a Genetic Algorithm uses chromosomes of the form
x=abcdefgh with a fixed length of eight genes . Each gene
can be any digit between 0 and 9 . Let the fitness of
individual x be calculated as :
f(x) =(a+b)-(c+d)+(e+f)- ( g+h)
And let the initial population consist of four individuals x1, ...
,x4 with the following chromosomes :
X1 = 6 5 4 1 3 5 3 2
F(x1) =(6+5)-(4+1)+(3+5)-(3+2) = 9
X2 = 8 7 1 2 6 6 0 1
F(x2) = (8+7)-(1+2)+(6+6)-(0+1) = 23
X3 = 2 3 9 2 1 2 8 5
F(x3) = (2+3)-(9+2)+(1+2)-(8+5) = -16
X4= 4 1 8 5 2 0 9 4
F(x4) = (4+1)-(8+5)+(2+0)-(9+4) = -19
The arrangement is ( assume maximization )
X2
x1
x3
x4
( the fittest individual )
( least fit individual )

Put the calculations in

table String
for simplicity

Individual
Fitnes Arrangement Assume
Representatio
s
s
maximization
n
X1
X2
X3
X4

65413532

X2(fittest individual)

87126601

23

X1(second fittest
individual)

23921285

-16

X3 (third fittest
individual)

41852094

-19

X4 (least fit individual)

So Average fitness :-0.75

Best : 23 Worst : -19
Average fitness = ( 9+23+ -16 + -19)/ 4 =-0.75

X2 = 8
1
X1 = 6
2

Offspring 1 = 8
2
Offspring 2 = 6
1

7
5

4Middle1
crossover

Offspring 3 = 6
2
Offspring 4 = 2

crossover
X1 = 6
2
X3 = 2
5

crossover

X2 = 8
X3 = 2

7
3

Offspring 5 = 8
Offspring 6 = 2

1
9

2
2

6
1

6
2

0
8

1
5

3
7

1
1

2
2

6
6

6
2

8
8

1
1

Offspring 1 = 8
2
F (Offspring 1)
Offspring 2 = 6
1
F (Offspring 2)
Offspring 3 = 6
2
F (Offspring 3)
Offspring 4 = 2
5
F (Offspring 4)
Offspring 5 = 8
1
F (Offspring 5)

=(8+7)-(1+2)+(3+5)-(3+2) = 15
5
4
1
6

=(6+5)-(4+1)+(6+6)-(0+1) = 17
5
9
2
1

=(6+5)-(9+2)+(1+2)-(3+2) = -2
3
4
1
3

=(2+3)-(4+1)+(3+5)-(8+5) = -5
3
1
2
6

=(8+3)-(1+2)+(6+6)-(8+1) = 11

Put the calculation in table for simplicity

Individuals

String Representation

Fitness

Offspring 1

87123532

15

Offspring 2

65416601

17

Offspring 3

65921232

-2

Offspring 4

23413585

-5

Offspring 5

87921201

11

Offspring 6

23926601

Average fitness : 6.833

Worst : -5

Best : 17

So that , the overall fitness is improved , since the

average is better and worst is improved .

Example: The Knapsack

Problem

You are going on an overnight hike and

have a number of items that you could take
along. Each item has a weight (in pounds)
and a benefit or value to you on the hike(for
measurements sake lets say, in US dollars),
and you can take one of each item at most.
There is a capacity limit on the weight you
can carry (constraint). This problem only
illustrates one constraint, but in reality
there could be many constraints including
volume, time, etc.

GA Example: The Knapsack

Problem

Item:
1 2 3 4 5 6 7
Benefit: 5 8 3 2 7 9 4
Weight: 7 8 4 10 4 6 4
Knapsack holds a maximum of 22 pounds
Fill it to get the maximum benefit
Solutions take the form of a string of 1s and 0s
Solutions: Also known as strings of genes called Chromosomes

1. 0101010
2. 1100100
3. 0100111

Example: The Knapsack

Problem

We represent a solution as a string of

seven 1s and 0s and the fitness function as
the total benefit, which is the sum of the
gene values in a string solution times their
representative benefit coefficient.
The method generates a set of random
solutions (initial parents), uses total benefit
as the fitness function and selects the
parents randomly to create generations of
offspring by crossover and mutation.

Knapsack Example
Typically,

a string of 1s and 0s can

represent a solution.
Possible solutions generated by the
system using Reproduction,
Crossover, or Mutations
1. 0101010
2. 1100100
3. 0100111

Knapsack Example
Solution 1
Item

Solutio 0
n
Benefit 5

Weight

10

Benefit 8 + 2 + 9 = 19
Weight 8 + 10 + 6 = 24

Knapsack Example
Solution 2
Item

Solutio 1
n
Benefit 5

Weight

10

Benefit 5 + 8 + 7 = 20
Weight 7 + 8 + 4 = 19

Knapsack Example
Solution 3
Item

Solutio 0
n
Benefit 5

Weight

10

Benefit 8 + 7 + 9 + 4 = 28
Weight 8 + 4 + 6 + 4 = 22

Knapsack Example

Solution 3 is clearly the best solution

and has met our conditions, therefore,
item number 2, 5, 6, and 7 will be taken
on the hiking trip. We will be able to get
the most benefit out of these items
while still having weight equal to 22
pounds.
This is a simple example illustrating a
genetic algorithm approach.

Knapsack Problem
To understand GA must work with the following
problem:
(Knap Sack Problem)
Thief wants to steal gold store.
Thief has a bag(the bag can hold a specific
weight).
Every piece of gold has a specific weight and price.
Thief wants to steal gold with high price but the
weight must equal or less than the weight that bag
can hold it.
If we gave every gold piece a specific number
1,2,3,,n(suggest n=8 in this example).
weight
price

1
5
100

2
3
30

3
10
250

4
6
150

5
5
50

6
5
75

7
4
50

8
4
50

1-Encoding (representation)
(gene,chromosome)
Chromosome could be:
Bit strings (101101010100).
Real numbers (43.1,45.2,66.3,11.0).
Permutation of elements (E11 E3 E7 E1 E15).
Integer Numbers (11,12,54,98,625,1).
Any data structures.
In knap sack problem can represent any solution
as chromosome by using bit string of length 8.
Ex:- 1 1 0 1 0 0 0 1
87654321
1(gene):this piece taken, 0(gene):this piece
untaken.

2-Initialize population

1
2
3
4
5
6

Implementers specify population size .

To initialize population create
chromosomes randomly and store them in
list of length the population size.
In our problem lets take population size 6
chromosomes.
We can initialize population a following:

"10100001"
"01110011"
"11110000"
"00110011"
"01010101"
"00001111"

3-Evaluation of population.

Giving every chromosome in population

fitness value by using fitness function.
Fitness functions will differ according to the
problem and encoding technique.
Fitness function returns a single
numerical(fitness) which reflex the utility or
the ability of the individual which that
chromosome represents.
Fitness function can calculate : strength,
weight, width, maximum load,cost,construction
time or combination of all these.
Fitness value well be stored with chromosome.

chromosome

Fitnessfunction

Fitnessvalue

Chromosome
1
2
3
4
5
6

"10100001"
"01110011"
"11110000"
"00110011"
"01010101"
"00001111"

fitness value
225
305
225
225
450
530

In our example we will make fitness function as

4-Selection of new
parents(reproduction)

Individuals are selected from population randomly or

by using any selection method to improve the
population itself.
Good individuals will probably be selected several
times in a generation ,poor ones may not be at all.

Methods of selection

Random ,Best, Tournament, Roulette wheel,

Truncation, Rank, Exponential, Boltzman,
Steady state, Interactive and binary
tournament selection.
In our example we will use Truncation selection
with parameter 3.
search best 3 chromosomes and then select 6
chromosomes randomly from these three
chromosomes and store them as new population to
be used in the next step.

Oldpopulation

1
2
3
4
5
6

chromosome

fitnes value

"10100001"
"01110011"
"11110000"
"00110011"
"01010101"
"00001111"

225

chromosome

Searchbest3
chromosomes

Newpopulation

1
2
3
4
5
6

305
225
225
450
530

fitnes value

1 "01110011"
2 "01010101"
3 "00001111"

305

chromosome

fitnes value

"01010101"
"00001111"
"00001111"
"00001111"
"01110011"
"01010101"

450

450
530

530
530
530
305
450

5-Crossover

Crossover is performed with probability Pcross

(crossover probability or crossover rate ) between
two selected individuals, called parents, by
exchanging parts of their genes to form two new
individuals called offsprings.
The simplest method know as single point
crossover.
Single point crossover take 2 individual and cut
their chromosome strings at randomly chosen
position, to produce 2 head segments and 2 tail
segments .The tail segments are then swapped
over to produce 2 new full length chromosomes.
Pcross (crossover probability or crossover rate )
is typically between 0.6 and 1.0
There is also Multi-Point, Uniform, Bit
Simulated, Problem Centered and
specialized crossover techniques.

wewilldoitjust
forfirsttwo
parents.
Pcross=0.6

1
2
3
4
5
6

chromosome

fitnes value

"01010101"
"00001111"
"00001111"
"00001111"
"01110011"
"01010101"

450
530
530
530
305
450

Selecttwoparent(1,2)
Generaterandomnumberbetween0.0-1.0(0.3)
0.3<=0.6(yes)applycrossover
generaterandomnumberbetween1-8(3)
old 010101 0 1
000011 1 1
new 010101 1 1
000011 0 1 swap tails
Dothisforeachpairinpopulation.

6-Mutation
Applied to each child individually after crossover
.
It alters some of genes in chromosome with
small probability .
Must specify Pmut(mutation probability that is
relatively small) therefore a few number of
chromosomes will be mutated.
In our example:
suppose Pmut =0.2
generate number between 0-1 (0.01)
0.01<=0.2(yes) apply mutation.
Generate number between 1-8(6)
0 1 0 1 0 1 0 1 => 0 1 1 1 0 1 0 1
Do this for each chromosome in population.

Termination Criteria
There exist three termination
condition type:
1-Time:in seconds, in minutes and may
be in hours according to the problem
that you have it.
2-Number of generations: in hundreds,
in thousands may be in millions
according to the problem you have it.
3-convergence: when 95% of populations
have the same fitness value we can say
the convergence started to appear and
the user can stop its genetic program to
take the result.

The Knapsack Problem

The knapsack
problem,
though simple,
has many
important
applications
including
determining
what items to
take on a space
ship mission.

Genetic Algorithms
Genetic Algorithms are a type of machine
learning for representing and solving
complex problems.
They provide a set of efficient, domainindependent search heuristics for a broad
spectrum of applications.
A genetic algorithm interprets information
that enables it to reject inferior solutions
and accumulate good ones, and thus it
learns about its universe.

Genetic Algorithm
Application Areas

Dynamic process control

Induction of rule optimization
Discovering new connectivity topologies
Simulating biological models of behavior and evolution
Complex design of engineering structures
Pattern recognition
Scheduling
Transportation
Layout and circuit design
Telecommunication
Graph-based problems

Business Applications

Schedule Assembly lines at Volvo Truck North America

Channel 4 Television (England) to schedule
commercials
Driver scheduling in a public transportation system
Jobshop scheduling
Assignment of destinations to sources
Trading stocks
Productivity in whisky-making is increased
Often genetic algorithm hybrids with other AI methods