Scribd
Upload
484 views

Max One

This document provides an overview of genetic algorithms. It describes genetic algorithms as optimization techniques inspired by biological evolution, using techniques like inheritance, mutation, selection, and crossover. The document explains the basic components and process of a genetic algorithm, including initializing a random population, evaluating fitness, selecting individuals for reproduction, crossing over genes via probabilistic crossover, and mutating offspring via probabilistic mutation. An example problem of maximizing the number of 1s in a binary string is used to illustrate how a genetic algorithm would work over multiple generations to evolve better solutions.

Uploaded by

Heba Ahmed
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
484 views

Max One

This document provides an overview of genetic algorithms. It describes genetic algorithms as optimization techniques inspired by biological evolution, using techniques like inheritance, mutation, selection, and crossover. The document explains the basic components and process of a genetic algorithm, including initializing a random population, evaluating fitness, selecting individuals for reproduction, crossing over genes via probabilistic crossover, and mutating offspring via probabilistic mutation. An example problem of maximizing the number of 1s in a binary string is used to illustrate how a genetic algorithm would work over multiple generations to evolve better solutions.

Uploaded by

Heba Ahmed
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 20

Supervisor:

Dr. Amr Badr


Presented by

Mohammed Wahbi
Business Plan

Algorithms in Nature
Genetic algorithms
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.

What is GA
A genetic algorithm (or GA) is a search technique used
in computing to find true or approximate solutions to
optimization and search problems.
(GA)s are categorized as global search heuristics.
(GA)s are a particular class of evolutionary algorithms
that use techniques inspired by evolutionary biology
such as inheritance, mutation, selection, and crossover
(also called recombination).

What is GA Cont...
The evolution usually starts from a population of
randomly generated individuals and happens in
generations.

In each generation, the fitness of every individual in the


population is evaluated, multiple individuals are selected
from the current population (based on their fitness), and
modified to form a new population.

Vocabulary
Individual - Any possible solution
Population - Group of all individuals
Fitness Target function that we are optimizing (each
individual has a fitness)
Trait - Possible aspect (features) of an individual
Genome - Collection of all chromosomes (traits) for an
individual.

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
(probabilistically) keep a subset of the best solutions
Use these solutions to generate a new population
Quit when you have a satisfactory solution (or you run
out of time)

The OneMax Problem


The OneMax Problem [SE91] (or BitCounting) is a simple
problem consisting in maximizing the number of ones of a
bitstring.

Formally, this problem can be described as finding a string


= * 1 , 2 , 3 , . , , + , with
=1 , , that
maximizes the following equation:
( ) =

=1 ,

Algorithm Psedudocode
generation = 0;
Initialization (popSize); // at random or from a file

while(!TerminationCondition())
{
generation = generation + 1;

CalculateFitness(); // ... of new genotypes


Selection(); // select genotypes that will reproduce
Crossover(pcross); // mate pcross of them on average
Mutation(pmut); // mutate all the offspring with Bernoulli
// probability pmut over genes
}

Illustration
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`

Illustration 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

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

Selection
We randomly (using a biased coin) select a subset of the
individuals based on their fitness:

Area is
Proportional
to fitness
value

n
3
4

Selected set
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)

Crossover (Step2 )
Next we mate strings for crossover. For each couple we
first decide (using some pre-defined probability, for
instance 0.6) whether to actually perform the crossover
or not

If we decide to actually perform crossover, we


randomly extract the crossover points, for instance 2
and 5

Crossover result
s1` = 1111010101 s2` = 1110110101 Before crossover:
After crossover:
s1`` = 1110110101 s2`` = 1111010101

Step 3: mutations
Initial strings
s1`` =
1110110101
s2`` =
1111010101

s3`` =
1110111101
s4`` =
0111000101
s5`` =
0100011101
s6`` =
1110110011

After mutating
s1``` =
1110100101
s2``` =
1111110100
s3``` =
1110101111
s4``` =
0111000101
s5``` =
0100011101
s6``` =
1110110001

iterate
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

Complexity Analysis

Thanks

You might also like