Chapter+3+ +GA+ (Population+Representation+ +Fitness+Function)

Genetic Algorithm
Chapter 3
Genetic Algorithms:
Population Representation -
Fitness Function
Dr. Fatma M. Talaat

Contents
1. Chapter 1: Introduction to Genetic Algorithm
2. Chapter 2: Genetic Algorithm in Machine Learning
3. Chapter 3: Genetic Algorithms: Population Representation - Fitness

Function
4. Chapter 4: Genetic Algorithms: Selection – Crossover
5. Chapter 5: The Applications of Genetic Algorithms in Medicine
6. Chapter 6: Practical Examples of Genetic Algorithms
7. Chapter 7: The use of GA in the field of robotics

Chapter 3: Genetic Algorithms:
Population Representation - Fitness
Function
3
Contents
1. Genetic Algorithm Basic Structure
2. A generalized pseudo-code for a GA
3. Genotype Representation
○ 3.1. Binary Representation
○ 3.2. Real Valued Representation
○ 3.3. Integer Representation
○ 3.4. Permutation Representation
4. Genetic Algorithms – Population

○ 4.1. Population Initialization
○ 4.2. Population Models
5. Genetic Algorithms - Fitness Function
6. Simple Genetic Algorithm From Scratch in Python
7. Genetic Algorithm for OneMax

The basic structure of a GA is as follows:
• We start with an initial population (which may be generated at random or seeded by other heuristics),
• Select parents from this population for mating.
• Apply crossover and mutation operators on the parents to generate new off-springs.
• And finally these off-springs replace the existing individuals in the population and the process repeats.
In this way genetic algorithms actually try to mimic the human evolution to some extent.
2. A generalized pseudo-code for a GA is explained in the following program
GA()
initialize population
find fitness of population
while (termination criteria is reached) do

parent selection
crossover with probability pc
mutation with probability pm
decode and fitness calculation
survivor selection
find best
return best
• One of the most important decisions to make while implementing a genetic algorithm is deciding the
representation that we will use to represent our solutions.
• It has been observed that improper representation can lead to poor performance of the GA.
• Therefore, choosing a proper representation, having a proper definition of the mappings between
the phenotype and genotype spaces is essential for the success of a GA.
• In this section, we present some of the most commonly used representations for genetic algorithms.
3.1. Binary Representation

3.2. Real Valued Representation
3.3. Integer Representation
3.4. Permutation Representation
• This is one of the simplest and most widely used representation in GAs.
• In this type of representation the genotype consists of bit strings.
• For some problems when the solution space consists of Boolean decision variables – yes or no, the
binary representation is natural.
• Take for example the 0/1 Knapsack Problem. If there are n items, we can represent a solution by
a binary string of n elements, where the xth element tells whether the item x is picked (1) or not (0).
• For other problems, specifically those dealing with numbers, we can represent the numbers with
their binary representation.
• The problem with this kind of encoding is that different bits have different significance and therefore
mutation and crossover operators can have undesired consequences.
• This can be resolved to some extent by using Gray Coding, as a change in one bit does not have
a massive effect on the solution.
3.2. Real Valued Representation
• For problems where we want to define the genes using continuous rather than discrete variables,
the real valued representation is the most natural.
• The precision of these real valued or floating point numbers is however limited to the computer.
3.3. Integer Representation
• For discrete valued genes, we cannot always limit the solution space to binary ‘yes’ or ‘no’.
• For example, if we want to encode the four distances – North, South, East and West, we can
encode them as {0,1,2,3}.
• In such cases, integer representation is desirable.

3.4. Permutation Representation
• In many problems, the solution is represented by an order of elements. In such cases permutation
representation is the most suited.
• A classic example of this representation is the travelling salesman problem (TSP).

• In this problem, the salesman has to take a tour of all the cities, visiting each city exactly once and
come back to the starting city.
• The total distance of the tour has to be minimized.

• The solution to this TSP is naturally an ordering or permutation of all the cities and therefore using a
permutation representation makes sense for this problem.
4. Genetic Algorithms - Population
• Population is a subset of solutions in the current generation.

• It can also be defined as a set of chromosomes.
• There are several things to be kept in mind when dealing with GA population:
1. The diversity of the population should be maintained otherwise it might lead to premature
convergence.
2. The population size should not be kept very large as it can cause a GA to slow down, while a smaller
population might not be enough for a good mating pool. Therefore, an optimal population size needs to
be decided by trial and error.
• The population is usually defined as a two dimensional array of – size population, chromosome
size.
4.1. Population Initialization
• It has been observed that the entire population should not be initialized using a heuristic, as it can
result in the population having similar solutions and very little diversity.
• It has been experimentally observed that the random solutions are the ones to drive the population to
optimality.
• Therefore, with heuristic initialization, we just seed the population with a couple of good
solutions, filling up the rest with random solutions rather than filling the entire population with
heuristic based solutions.
• It has also been observed that heuristic initialization in some cases, only affects on the initial
fitness of the population, but in the end, it is the diversity of the solutions which lead to optimality.
4.2. Population Models
There are two population models widely in use:
1) Steady State
• In steady state GA, we generate one or two off-springs in each iteration and they replace one or two
individuals from the population.
• A steady state GA is also known as Incremental GA.
2) Generational
• In a generational model, we generate ‘n’ off-springs, where n is the population size, and the entire
population is replaced by the new one at the end of the iteration.
• The fitness function: is a function which takes a candidate solution to the problem as input and
produces as output how “fit” our how “good” the solution is with respect to the problem in
consideration.
• Calculation of fitness value is done repeatedly in a GA and therefore it should be sufficiently fast.
• A slow computation of the fitness value can adversely affect a GA and make it exceptionally slow.
• In most cases the fitness function and the objective function are the same as the objective is to either
maximize or minimize the given objective function. However, for more complex problems with multiple
objectives and constraints, an Algorithm Designer might choose to have a different fitness function.
A fitness function should possess the following characteristics:

1. The fitness function should be sufficiently fast to compute.
2. It must quantitatively measure how fit a given solution is or how fit individuals can be
produced from the given solution.
• In some cases, calculating the fitness function directly might not be possible due to the inherent
complexities of the problem at hand.
• In such cases, we do fitness approximation to suit our needs.
• The following image shows the fitness calculation for a solution of the 0/1 Knapsack.
• It is a simple fitness function which just sums the profit values of the items being picked (which have
a 1), scanning the elements from left to right till the knapsack is full.
• The Genetic Algorithm is a stochastic global search optimization algorithm.

• Steps:
1) Population Initialization
- The first step is to create a population of random bitstrings. We could use boolean values True and
False, string values ‘0’ and ‘1’, or integer values 0 and 1. In this case, we will use integer values.
- We can generate an array of integer values in a range using the randint() function, and we can
specify the range as values starting at 0 and less than 2, e.g. 0 or 1. We will also represent a
candidate solution as a list instead of a NumPy array to keep things simple.
- An initial population of random bitstring can be created as follows, where “n_pop” is a hyperparameter
that controls the population size and “n_bits” is a hyperparameter that defines the number of bits in a
single candidate solution:
# initial population of random bitstring

pop = [randint(0, 2, n_bits).tolist() for _ in range(n_pop)]
- Next, we can enumerate over a fixed number of algorithm iterations, in this case, controlled by a
hyperparameter named “n_iter“.
# enumerate generations
for gen in range(n_iter):
- The first step in the algorithm iteration is to evaluate all candidate solutions.
- We will use a function named objective() as a generic objective function and call it to get a fitness
score, which we will minimize.
# evaluate all candidates in the population

scores = [objective(c) for c in pop]
2) Selection
- We can then select parents that will be used to create children.
- The tournament selection procedure can be implemented as a function that takes the population and
returns one selected parent. The k value is fixed at 3 with a default argument, but you can experiment
with different values if you like.
# tournament selection
def selection(pop, scores, k=3):
# first random selection
selection_ix = randint(len(pop))
for ix in randint(0, len(pop), k-1):
# check if better (e.g. perform a tournament)
if scores[ix] < scores[selection_ix]:
selection_ix = ix
return pop[selection_ix]
- We can then call this function one time for each position in the population to create a list of parents.
# select parents
selected = [selection(pop, scores) for _ in range(n_pop)]
3) Crossover
- We can then create the next generation.
- This first requires a function to perform crossover. This function will take two parents and the
crossover rate. The crossover rate is a hyperparameter that determines whether crossover is
performed or not, and if not, the parents are copied into the next generation. It is a probability and
typically has a large value close to 1.0.
- The crossover() function below implements crossover using a draw of a random number in the range
[0,1] to determine if crossover is performed, then selecting a valid split point if crossover is to be
performed.
# crossover two parents to create two children

def crossover(p1, p2, r_cross):
# children are copies of parents by default
c1, c2 = p1.copy(), p2.copy()
# check for recombination
if rand() < r_cross:
# select crossover point that is not on the end of the string
pt = randint(1, len(p1)-2)
# perform crossover
c1 = p1[:pt] + p2[pt:]
c2 = p2[:pt] + p1[pt:]
return [c1, c2]
4) Mutation
- We also need a function to perform mutation.
- This procedure simply flips bits with a low probability controlled by the “r_mut” hyperparameter.
# mutation operator
def mutation(bitstring, r_mut):
for i in range(len(bitstring)):
# check for a mutation
if rand() < r_mut:
# flip the bit
bitstring[i] = 1 - bitstring[i]
- We can then loop over the list of parents and create a list of children to be used as the next
generation, calling the crossover and mutation functions as needed.
# create the next generation

children = list()
for i in range(0, n_pop, 2):
# get selected parents in pairs
p1, p2 = selected[i], selected[i+1]
# crossover and mutation
for c in crossover(p1, p2, r_cross):
# mutation
mutation(c, r_mut)
# store for next generation
children.append(c)
- We can tie all of this together into a function named genetic_algorithm() that takes the name of the
objective function and the hyperparameters of the search, and returns the best solution found during
the search.
# genetic algorithm
def genetic_algorithm(objective, n_bits, n_iter, n_pop, r_cross, r_mut):
# keep track of best solution
best, best_eval = 0, objective(pop[0])
# check for new best solution
for i in range(n_pop):
if scores[i] < best_eval:
best, best_eval = pop[i], scores[i]
print(">%d, new best f(%s) = %.3f" % (gen, pop[i], scores[i]))
# select parents
children = list()
# mutation
mutation(c, r_mut)
children.append(c)
# replace population
pop = children
return [best, best_eval]
- In this section, we will apply the genetic algorithm to a binary string-based optimization problem.
- The problem is called OneMax and evaluates a binary string based on the number of 1s in the string.
For example, a bitstring with a length of 20 bits will have a score of 20 for a string of all 1s.
- Given we have implemented the genetic algorithm to minimize the objective function, we can add a
negative sign to this evaluation so that large positive values become large negative values.
- The onemax() function below implements this and takes a bitstring of integer values as input and
returns the negative sum of the values.
- In this section, we will apply the genetic algorithm to a binary string-based optimization problem.
- The problem is called OneMax and evaluates a binary string based on the number of 1s in the string.
For example, a bitstring with a length of 20 bits will have a score of 20 for a string of all 1s.
- Given we have implemented the genetic algorithm to minimize the objective function, we can add a
negative sign to this evaluation so that large positive values become large negative values.
- The onemax() function below implements this and takes a bitstring of integer values as input and
returns the negative sum of the values.
# objective function
def onemax(x):
return -sum(x)
- Next, we can configure the search.

- The search will run for 100 iterations and we will use 20 bits in our candidate solutions, meaning the
optimal fitness will be -20.0.
- The population size will be 100, and we will use a crossover rate of 90 percent and a mutation rate of
5 percent. This configuration was chosen after a little trial and error.
...
# define the total iterations
n_iter = 100
# bits
n_bits = 20
# define the population size
n_pop = 100
# crossover rate
r_cross = 0.9
# mutation rate
r_mut = 1.0 / float(n_bits)
- The search can then be called and the best result reported.
# perform the genetic algorithm search

best, score = genetic_algorithm(onemax, n_bits, n_iter, n_pop, r_cross, r_mut)
print('Done!')
print('f(%s) = %f' % (best, score))
- Tying this together, the complete example of applying the genetic algorithm to the OneMax objective
function is listed below.
# genetic algorithm search of the one max optimization problem
from numpy.random import randint
from numpy.random import rand
# objective function
def onemax(x):
return -sum(x)
# tournament selection
def selection(pop, scores, k=3):
# first random selection
selection_ix = randint(len(pop))
for ix in randint(0, len(pop), k-1):
# check if better (e.g. perform a tournament)
if scores[ix] < scores[selection_ix]:
selection_ix = ix
return pop[selection_ix]
# crossover two parents to create two children
def crossover(p1, p2, r_cross):
# children are copies of parents by default
c1, c2 = p1.copy(), p2.copy()
# check for recombination
if rand() < r_cross:
# select crossover point that is not on the end of the string
pt = randint(1, len(p1)-2)
# perform crossover
c1 = p1[:pt] + p2[pt:]
c2 = p2[:pt] + p1[pt:]
return [c1, c2]
# mutation operator
def mutation(bitstring, r_mut):
for i in range(len(bitstring)):
# check for a mutation
if rand() < r_mut:
# flip the bit
bitstring[i] = 1 - bitstring[i]
# genetic algorithm
def genetic_algorithm(objective, n_bits, n_iter, n_pop, r_cross, r_mut):
# keep track of best solution
best, best_eval = 0, objective(pop[0])
# check for new best solution
for i in range(n_pop):
if scores[i] < best_eval:
best, best_eval = pop[i], scores[i]
print(">%d, new best f(%s) = %.3f" % (gen, pop[i], scores[i]))
# select parents
children = list()
# mutation
mutation(c, r_mut)
children.append(c)
# replace population
pop = children
return [best, best_eval]
# define the total iterations
n_iter = 100
# bits
n_bits = 20
# define the population size
n_pop = 100
# crossover rate
r_cross = 0.9
# mutation rate
r_mut = 1.0 / float(n_bits)
# perform the genetic algorithm search
best, score = genetic_algorithm(onemax, n_bits, n_iter, n_pop, r_cross, r_mut)
print('Done!')
print('f(%s) = %f' % (best, score))
- Running the example will report the best result as it is found along the way, then the final best
solution at the end of the search, which we would expect to be the optimal solution.
- Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or
differences in numerical precision. Consider running the example a few times and compare the
average outcome.
- In this case, we can see that the search found the optimal solution after about eight generations.
Thanks!
Any
questions?
44

Chapter+3+ +GA+ (Population+Representation+ +Fitness+Function)

Uploaded by

Copyright:

Available Formats

You might also like

Chapter+3+ +GA+ (Population+Representation+ +Fitness+Function)

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter+3+ +GA+ (Population+Representation+ +Fitness+Function)

Uploaded by

Copyright:

Available Formats

Genetic Algorithm

Dr. Fatma M. Talaat

1. Chapter 1: Introduction to Genetic Algorithm

2. Chapter 2: Genetic Algorithm in Machine Learning

3. Chapter 3: Genetic Algorithms: Population Representation - Fitness

4. Chapter 4: Genetic Algorithms: Selection – Crossover

5. Chapter 5: The Applications of Genetic Algorithms in Medicine

6. Chapter 6: Practical Examples of Genetic Algorithms

7. Chapter 7: The use of GA in the field of robotics

2. A generalized pseudo-code for a GA

4. Genetic Algorithms – Population

6. Simple Genetic Algorithm From Scratch in Python

7. Genetic Algorithm for OneMax

The basic structure of a GA is as follows:

• Select parents from this population for mating.

while (termination criteria is reached) do

3.1. Binary Representation

• In this type of representation the genotype consists of bit strings.

• In such cases, integer representation is desirable.

• A classic example of this representation is the travelling salesman problem (TSP).

• The total distance of the tour has to be minimized.

• Population is a subset of solutions in the current generation.

There are two population models widely in use:

A fitness function should possess the following characteristics:

• The Genetic Algorithm is a stochastic global search optimization algorithm.

# initial population of random bitstring

# evaluate all candidates in the population

# crossover two parents to create two children

# create the next generation

- Next, we can configure the search.

# perform the genetic algorithm search

You might also like