Introduction to Genetic Algorithms with Python - Hello World!

Introduction to
Genetic Algorithms
with Python
Hello World!

Reach back in your
memory to a game we
played as kids.

Pick a number
between 1 and 10.
(pick 3)

That works
reasonably well for
1..10 but...

it becomes boring as
we increase the range
to 1..100.

Because we have
no way to
improve our guesses.

The guess is either
right or wrong

so it becomes a
mechanical process.

Is it 1? No
Is it 2? No
Is it 3? No
Is it 4? No

So, to make it
more interesting

instead of no,
let's say
higher or lower.

At this point, the
person who evolves
the most efficient
guessing strategy wins.

When playing this
game we make use of
domain knowledge.

For example,
after this sequence:
1? Higher
7? Lower

Why wouldn't we guess
8, 9, or 10?

Because we know
that those numbers
are not lower than 7.

We use our memory
of what we've tried,

and our
knowledge of numbers
to make better guesses.

A genetic algorithm
does not know
what lower means.

It does not learn.
It will make the same
mistakes every time.

It will only be as good
at solving a problem

as the person
who writes the code.

And yet, it can be used
to find solutions to
problems that

humans would
struggle to solve or
could not solve at all.

Genetic algorithms use
random exploration
of the problem space

combined with
evolutionary processes
like mutation and

crossover - exchange
of genetic information -
to improve guesses.

But also, because they
have no experience in
the problem domain

they try things
a human would never
think to try.

Thus, a person using
a genetic algorithm

may learn more about
the problem space and
potential solutions.

This helps them to
improve the algorithm,
in a virtuous cycle.

Genetic algorithms
should make
informed guesses.

Let's see how
this applies to
guessing a password.

We'll start by randomly
generating an initial
sequence of letters

then mutate/change
one random letter
in that sequence

at a time until the
sequence of letters is
"Hello World!"

Psuedo code
_letters = [a..zA..Z !]
target = "Hello World!"
guess = get 12 random letters from _letters
while guess != target:
index = get random value from [0..length of target]
guess[index] = get 1 random value from _letters

If you try this in your
favorite programming
language...

you'll find that it
performs worse than
guessing numbers
using yes and no

because it cannot tell
when one guess is
better than another.

So, let's help it
make an
informed guess

by telling it how many
guessed letters are
in the correct spots.

For example
"World.Hello?"
would get 2

because only the 4th
letter of each word
is correct.

The number 2
indicates how close the
answer is to correct.

This is called
the fitness value.

"hello_world?"
would get
a fitness value of 9

because 9 letters are
correct. Only the
h, w, and ? are wrong.

Now we're ready to
write some Python.

Start with a
set of letters for genes
and a target password

Genes and target
geneSet = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!."
target = "Hello World!"
Note: You can run the code in your browser at
https://repl.it/CZL1/1

Next we need a way to
generate a random
string of letters.

Generate parent
import random
…
def generate_parent(length):
genes = []
while len(genes) < length:
sampleSize = min(length - len(genes), len(geneSet))
genes.extend(random.sample(geneSet, sampleSize))
return ''.join(genes)

The fitness value
the genetic algorithm
provides

is the only feedback
the engine gets

to guide it
toward a solution.

Our fitness value is
the total number
of correct letters.

Get fitness
def get_fitness(guess):
return sum(1 for expected, actual in zip(target, guess)
if expected == actual)

We also need
a way to produce
a new guess

by mutating
the current guess.

We start by
converting the parent
string to an array.

Mutate
def mutate(parent):
childGenes = list(parent)
...

Then replace
1 letter in the array
with a randomly
selected one

Mutate (cont'd)
...
index = random.randint(0, len(parent) - 1)
newGene, alternate = random.sample(geneSet, 2)
childGenes[index] = alternate
if newGene == childGenes[index]
else newGene
...

and then
recombine the result
into a string.

Mutate (cont'd)
...
return ''.join(childGenes)

Next, it is important
to monitor
what is happening

so that we can
stop the engine
if it gets stuck.

It also allows us to
learn what works
and what does not

so we can
improve the algorithm.

To do that we display a
visual representation
of the gene sequence,

which may not be
the literal
gene sequence,

its fitness value and
the total run time.

Display
import datetime
...
def display(guess):
timeDiff = datetime.datetime.now() - startTime
fitness = get_fitness(guess)
print("{0}t{1}t{2}".format(guess, fitness, str(timeDiff)))

Sample output
ftljCDPvhasn 1 0:00:00

Now we're ready to
write the main
program.

Main
random.seed()
startTime = datetime.datetime.now()
bestParent = generate_parent(len(target))
bestFitness = get_fitness(bestParent)
display(bestParent)
...

Then we add
the heart of
the genetic engine.

It is a loop
that creates a guess,

Main loop
while True:
child = mutate(bestParent)
...

requests the fitness
for that guess

Main loop (cont'd)
...
childFitness = get_fitness(child)
...

then compares it to
the fitness of the
previous best guess

Main loop (cont'd)
…
if bestFitness >= childFitness:
continue
display(child)
if childFitness >= len(bestParent):
break
...

and keeps
the one with
the best fitness.

Main loop (cont't)
...
bestFitness, bestParent = childFitness, child

This cycle repeats
until a stop condition
occurs.

Here, we stop
when all the letters
match the target.

Sample output
ftljCDPvhasn 1 0:00:00
ftljC Pvhasn 2 0:00:00
ftljC Pohasn 3 0:00:00.001000
HtljC Pohasn 4 0:00:00.002000
HtljC Wohasn 5 0:00:00.004000
Htljo Wohasn 6 0:00:00.005000
Htljo Wohas! 7 0:00:00.008000
Htljo Wohls! 8 0:00:00.010000
Heljo Wohls! 9 0:00:00.013000
Hello Wohls! 10 0:00:00.013000
Hello Wohld! 11 0:00:00.013000
Hello World! 12 0:00:00.015000

Congratulations!
You've written
a genetic algorithm
in Python!

The next step is to
extract the genetic
engine code

from that specific to
the password problem
so it can be reused.

Ready for more?
Continue the lesson on CodeProject
or learn about my book.

Introduction to Genetic Algorithms with Python - Hello World!

Recommended

More Related Content

Similar to Introduction to Genetic Algorithms with Python - Hello World! (20)

Recently uploaded (20)

Introduction to Genetic Algorithms with Python - Hello World!