Release History¶

PyGAD 1.0.17¶
Release Date: 15 April 2020
- The pygad.GA class accepts a new argument named
fitness_func
which accepts a function to be used for calculating the fitness values for the solutions. This allows the project to be customized to any problem by building the right fitness function.
PyGAD 1.0.20¶
Release Date: 4 May 2020
- The pygad.GA attributes are moved from the class scope to the instance scope.
- Raising an exception for incorrect values of the passed parameters.
- Two new parameters are added to the pygad.GA class constructor
(
init_range_low
andinit_range_high
) allowing the user to customize the range from which the genes values in the initial population are selected. - The code object
__code__
of the passed fitness function is checked to ensure it has the right number of parameters.
PyGAD 2.0.0¶
Release Date: 13 May 2020
- The fitness function accepts a new argument named
sol_idx
representing the index of the solution within the population. - A new parameter to the pygad.GA class constructor named
initial_population
is supported to allow the user to use a custom initial population to be used by the genetic algorithm. If not None, then the passed population will be used. IfNone
, then the genetic algorithm will create the initial population using thesol_per_pop
andnum_genes
parameters. - The parameters
sol_per_pop
andnum_genes
are optional and set toNone
by default. - A new parameter named
callback_generation
is introduced in the pygad.GA class constructor. It accepts a function with a single parameter representing the pygad.GA class instance. This function is called after each generation. This helps the user to do post-processing or debugging operations after each generation.
PyGAD 2.1.0¶
Release Date: 14 May 2020
- The
best_solution()
method in the pygad.GA class returns a new output representing the index of the best solution within the population. Now, it returns a total of 3 outputs and their order is: best solution, best solution fitness, and best solution index. Here is an example:
solution, solution_fitness, solution_idx = ga_instance.best_solution()
print("Parameters of the best solution :", solution)
print("Fitness value of the best solution :", solution_fitness, "\n")
print("Index of the best solution :", solution_idx, "\n")
- A new attribute named
best_solution_generation
is added to the instances of the pygad.GA class. it holds the generation number at which the best solution is reached. It is only assigned the generation number after therun()
method completes. Otherwise, its value is -1.Example:
print("Best solution reached after {best_solution_generation} generations.".format(best_solution_generation=ga_instance.best_solution_generation))
- The
best_solution_fitness
attribute is renamed tobest_solutions_fitness
(plural solution). - Mutation is applied independently for the genes.
PyGAD 2.2.1¶
Release Date: 17 May 2020
- Adding 2 extra modules (pygad.nn and pygad.gann) for building and training neural networks with the genetic algorithm.
PyGAD 2.2.2¶
Release Date: 18 May 2020
- The initial value of the
generations_completed
attribute of instances from the pygad.GA class is0
rather thanNone
. - An optional bool parameter named
mutation_by_replacement
is added to the constructor of the pygad.GA class. It works only when the selected type of mutation is random (mutation_type="random"
). In this case, settingmutation_by_replacement=True
means replace the gene by the randomly generated value. IfFalse
, then it has no effect and random mutation works by adding the random value to the gene. This parameter should be used when the gene falls within a fixed range and its value must not go out of this range. Here are some examples:
Assume there is a gene with the value 0.5.
If mutation_type="random"
and mutation_by_replacement=False
,
then the generated random value (e.g. 0.1) will be added to the gene
value. The new gene value is 0.5+0.1=0.6.
If mutation_type="random"
and mutation_by_replacement=True
, then
the generated random value (e.g. 0.1) will replace the gene value. The
new gene value is 0.1.
None
value could be assigned to themutation_type
andcrossover_type
parameters of the pygad.GA class constructor. WhenNone
, this means the step is bypassed and has no action.
PyGAD 2.3.0¶
Release date: 1 June 2020
- A new module named
pygad.cnn
is supported for building convolutional neural networks. - A new module named
pygad.gacnn
is supported for training convolutional neural networks using the genetic algorithm. - The
pygad.plot_result()
method has 3 optional parameters namedtitle
,xlabel
, andylabel
to customize the plot title, x-axis label, and y-axis label, respectively. - The
pygad.nn
module supports the softmax activation function. - The name of the
pygad.nn.predict_outputs()
function is changed topygad.nn.predict()
. - The name of the
pygad.nn.train_network()
function is changed topygad.nn.train()
.
PyGAD 2.4.0¶
Release date: 5 July 2020
- A new parameter named
delay_after_gen
is added which accepts a non-negative number specifying the time in seconds to wait after a generation completes and before going to the next generation. It defaults to0.0
which means no delay after the generation. - The passed function to the
callback_generation
parameter of the pygad.GA class constructor can terminate the execution of the genetic algorithm if it returns the stringstop
. This causes therun()
method to stop.
One important use case for that feature is to stop the genetic algorithm
when a condition is met before passing though all the generations. The
user may assigned a value of 100 to the num_generations
parameter of
the pygad.GA class constructor. Assuming that at generation 50, for
example, a condition is met and the user wants to stop the execution
before waiting the remaining 50 generations. To do that, just make the
function passed to the callback_generation
parameter to return the
string stop
.
Here is an example of a function to be passed to the
callback_generation
parameter which stops the execution if the
fitness value 70 is reached. The value 70 might be the best possible
fitness value. After being reached, then there is no need to pass
through more generations because no further improvement is possible.
def func_generation(ga_instance):
if ga_instance.best_solution()[1] >= 70:
return "stop"
PyGAD 2.5.0¶
Release date: 19 July 2020
- 2 new optional parameters added to the constructor of the
pygad.GA
class which arecrossover_probability
andmutation_probability
.While applying the crossover operation, each parent has a random value generated between 0.0 and 1.0. If this random value is less than or equal to the value assigned to thecrossover_probability
parameter, then the parent is selected for the crossover operation.For the mutation operation, a random value between 0.0 and 1.0 is generated for each gene in the solution. If this value is less than or equal to the value assigned to themutation_probability
, then this gene is selected for mutation. A new optional parameter named
linewidth
is added to theplot_result()
method to specify the width of the curve in the plot. It defaults to 3.0.Previously, the indices of the genes selected for mutation was randomly generated once for all solutions within the generation. Currently, the genes’ indices are randomly generated for each solution in the population. If the population has 4 solutions, the indices are randomly generated 4 times inside the single generation, 1 time for each solution.
Previously, the position of the point(s) for the single-point and two-points crossover was(were) randomly selected once for all solutions within the generation. Currently, the position(s) is(are) randomly selected for each solution in the population. If the population has 4 solutions, the position(s) is(are) randomly generated 4 times inside the single generation, 1 time for each solution.
A new optional parameter named
gene_space
as added to thepygad.GA
class constructor. It is used to specify the possible values for each gene in case the user wants to restrict the gene values. It is useful if the gene space is restricted to a certain range or to discrete values. For more information, check the More about the ``gene_space` Parameter <https://pygad.readthedocs.io/en/latest/README_pygad_ReadTheDocs.html#more-about-the-gene-space-parameter>`__ section. Thanks to Prof. Tamer A. Farrag for requesting this useful feature.
PyGAD 2.6.0¶
Release Date: 6 August 2020
- A bug fix in assigning the value to the
initial_population
parameter. - A new parameter named
gene_type
is added to control the gene type. It can be eitherint
orfloat
. It has an effect only when the parametergene_space
isNone
. - 7 new parameters that accept callback functions:
on_start
,on_fitness
,on_parents
,on_crossover
,on_mutation
,on_generation
, andon_stop
.
PyGAD 2.7.0¶
Release Date: 11 September 2020
- The
learning_rate
parameter in thepygad.nn.train()
function defaults to 0.01. - Added support of building neural networks for regression using the
new parameter named
problem_type
. It is added as a parameter to bothpygad.nn.train()
andpygad.nn.predict()
functions. The value of this parameter can be either classification or regression to define the problem type. It defaults to classification. - The activation function for a layer can be set to the string
"None"
to refer that there is no activation function at this layer. As a result, the supported values for the activation function are"sigmoid"
,"relu"
,"softmax"
, and"None"
.
To build a regression network using the pygad.nn
module, just do the
following:
- Set the
problem_type
parameter in thepygad.nn.train()
andpygad.nn.predict()
functions to the string"regression"
. - Set the activation function for the output layer to the string
"None"
. This sets no limits on the range of the outputs as it will be from-infinity
to+infinity
. If you are sure that all outputs will be nonnegative values, then use the ReLU function.
Check the documentation of the pygad.nn
module for an example that
builds a neural network for regression. The regression example is also
available at this GitHub
project:
https://github.com/ahmedfgad/NumPyANN
To build and train a regression network using the pygad.gann
module,
do the following:
- Set the
problem_type
parameter in thepygad.nn.train()
andpygad.nn.predict()
functions to the string"regression"
. - Set the
output_activation
parameter in the constructor of thepygad.gann.GANN
class to"None"
.
Check the documentation of the pygad.gann
module for an example that
builds and trains a neural network for regression. The regression
example is also available at this GitHub
project:
https://github.com/ahmedfgad/NeuralGenetic
To build a classification network, either ignore the problem_type
parameter or set it to "classification"
(default value). In this
case, the activation function of the last layer can be set to any type
(e.g. softmax).
PyGAD 2.7.1¶
Release Date: 11 September 2020
- A bug fix when the
problem_type
argument is set toregression
.
PyGAD 2.7.2¶
Release Date: 14 September 2020
- Bug fix to support building and training regression neural networks with multiple outputs.
PyGAD 2.8.0¶
Release Date: 20 September 2020
- Support of a new module named
kerasga
so that the Keras models can be trained by the genetic algorithm using PyGAD.
PyGAD 2.8.1¶
Release Date: 3 October 2020
- Bug fix in applying the crossover operation when the
crossover_probability
parameter is used. Thanks to Eng. Hamada Kassem, Research and Teaching Assistant, Construction Engineering and Management, Faculty of Engineering, Alexandria University, Egypt.
PyGAD 2.9.0¶
Release Date: 06 December 2020
- The fitness values of the initial population are considered in the
best_solutions_fitness
attribute. - An optional parameter named
save_best_solutions
is added. It defaults toFalse
. When it isTrue
, then the best solution after each generation is saved into an attribute namedbest_solutions
. IfFalse
, then no solutions are saved and thebest_solutions
attribute will be empty. - Scattered crossover is supported. To use it, assign the
crossover_type
parameter the value"scattered"
. - NumPy arrays are now supported by the
gene_space
parameter. - The following parameters (
gene_type
,crossover_probability
,mutation_probability
,delay_after_gen
) can be assigned to a numeric value of any of these data types:int
,float
,numpy.int
,numpy.int8
,numpy.int16
,numpy.int32
,numpy.int64
,numpy.float
,numpy.float16
,numpy.float32
, ornumpy.float64
.
PyGAD 2.10.0¶
Release Date: 03 January 2021
- Support of a new module
pygad.torchga
to train PyTorch models using PyGAD. Check its documentation. - Support of adaptive mutation where the mutation rate is determined by the fitness value of each solution. Read the Adaptive Mutation section for more details. Also, read this paper: Libelli, S. Marsili, and P. Alba. “Adaptive mutation in genetic algorithms.” Soft computing 4.2 (2000): 76-80.
- Before the
run()
method completes or exits, the fitness value of the best solution in the current population is appended to thebest_solution_fitness
list attribute. Note that the fitness value of the best solution in the initial population is already saved at the beginning of the list. So, the fitness value of the best solution is saved before the genetic algorithm starts and after it ends. - When the parameter
parent_selection_type
is set tosss
(steady-state selection), then a warning message is printed if the value of thekeep_parents
parameter is set to 0. - More validations to the user input parameters.
- The default value of the
mutation_percent_genes
is set to the string"default"
rather than the integer 10. This change helps to know whether the user explicitly passed a value to themutation_percent_genes
parameter or it is left to its default one. The"default"
value is later translated into the integer 10. - The
mutation_percent_genes
parameter is no longer accepting the value 0. It must be>0
and<=100
. - The built-in
warnings
module is used to show warning messages rather than just using theprint()
function. - A new
bool
parameter calledsuppress_warnings
is added to the constructor of thepygad.GA
class. It allows the user to control whether the warning messages are printed or not. It defaults toFalse
which means the messages are printed. - A helper method called
adaptive_mutation_population_fitness()
is created to calculate the average fitness value used in adaptive mutation to filter the solutions. - The
best_solution()
method accepts a new optional parameter calledpop_fitness
. It accepts a list of the fitness values of the solutions in the population. IfNone
, then thecal_pop_fitness()
method is called to calculate the fitness values of the population.
PyGAD 2.10.1¶
Release Date: 10 January 2021
- In the
gene_space
parameter, anyNone
value (regardless of its index or axis), is replaced by a randomly generated number based on the 3 parametersinit_range_low
,init_range_high
, andgene_type
. So, theNone
value in[..., None, ...]
or[..., [..., None, ...], ...]
are replaced with random values. This gives more freedom in building the space of values for the genes. - All the numbers passed to the
gene_space
parameter are casted to the type specified in thegene_type
parameter. - The
numpy.uint
data type is supported for the parameters that accept integer values. - In the
pygad.kerasga
module, themodel_weights_as_vector()
function uses thetrainable
attribute of the model’s layers to only return the trainable weights in the network. So, only the trainable layers with theirtrainable
attribute set toTrue
(trainable=True
), which is the default value, have their weights evolved. All non-trainable layers with thetrainable
attribute set toFalse
(trainable=False
) will not be evolved. Thanks to Prof. Tamer A. Farrag for pointing about that at GitHub.
PyGAD 2.10.2¶
Release Date: 15 January 2021
- A bug fix when
save_best_solutions=True
. Refer to this issue for more information: https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/25
PyGAD 2.11.0¶
Release Date: 16 February 2021
- In the
gene_space
argument, the user can use a dictionary to specify the lower and upper limits of the gene. This dictionary must have only 2 items with keyslow
andhigh
to specify the low and high limits of the gene, respectively. This way, PyGAD takes care of not exceeding the value limits of the gene. For a problem with only 2 genes, then usinggene_space=[{'low': 1, 'high': 5}, {'low': 0.2, 'high': 0.81}]
means the accepted values in the first gene start from 1 (inclusive) to 5 (exclusive) while the second one has values between 0.2 (inclusive) and 0.85 (exclusive). For more information, please check the Limit the Gene Value Range section of the documentation. - The
plot_result()
method returns the figure so that the user can save it. - Bug fixes in copying elements from the gene space.
- For a gene with a set of discrete values (more than 1 value) in the
gene_space
parameter like[0, 1]
, it was possible that the gene value may not change after mutation. That is if the current value is 0, then the randomly selected value could also be 0. Now, it is verified that the new value is changed. So, if the current value is 0, then the new value after mutation will not be 0 but 1.
PyGAD 2.12.0¶
Release Date: 20 February 2021
- 4 new instance attributes are added to hold temporary results after
each generation:
last_generation_fitness
holds the fitness values of the solutions in the last generation,last_generation_parents
holds the parents selected from the last generation,last_generation_offspring_crossover
holds the offspring generated after applying the crossover in the last generation, andlast_generation_offspring_mutation
holds the offspring generated after applying the mutation in the last generation. You can access these attributes inside theon_generation()
method for example. - A bug fixed when the
initial_population
parameter is used. The bug occurred due to a mismatch between the data type of the array assigned toinitial_population
and the gene type in thegene_type
attribute. Assuming that the array assigned to theinitial_population
parameter is((1, 1), (3, 3), (5, 5), (7, 7))
which has typeint
. Whengene_type
is set tofloat
, then the genes will not be float but casted toint
because the defined array hasint
type. The bug is fixed by forcing the array assigned toinitial_population
to have the data type in thegene_type
attribute. Check the issue at GitHub: https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/27
Thanks to Andrei Rozanski [PhD Bioinformatics Specialist, Department of Tissue Dynamics and Regeneration, Max Planck Institute for Biophysical Chemistry, Germany] for opening my eye to the first change.
Thanks to Marios Giouvanakis, a PhD candidate in Electrical & Computer Engineer, Aristotle University of Thessaloniki (Αριστοτέλειο Πανεπιστήμιο Θεσσαλονίκης), Greece, for emailing me about the second issue.
PyGAD 2.13.0¶
Release Date: 12 March 2021
- A new
bool
parameter calledallow_duplicate_genes
is supported. IfTrue
, which is the default, then a solution/chromosome may have duplicate gene values. IfFalse
, then each gene will have a unique value in its solution. Check the Prevent Duplicates in Gene Values section for more details. - The
last_generation_fitness
is updated at the end of each generation not at the beginning. This keeps the fitness values of the most up-to-date population assigned to thelast_generation_fitness
parameter.
PyGAD 2.14.0¶
PyGAD 2.14.0 has an issue that is solved in PyGAD 2.14.1. Please consider using 2.14.1 not 2.14.0.
Release Date: 19 May 2021
- Issue
#40
is solved. Now, the
None
value works with thecrossover_type
andmutation_type
parameters: https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/40 - The
gene_type
parameter supports accepting alist/tuple/numpy.ndarray
of numeric data types for the genes. This helps to control the data type of each individual gene. Previously, thegene_type
can be assigned only to a single data type that is applied for all genes. For more information, check the More about the ``gene_type` Parameter <https://pygad.readthedocs.io/en/latest/README_pygad_ReadTheDocs.html#more-about-the-gene-type-parameter>`__ section. Thanks to Rainer Engel for asking about this feature in this discussion: https://github.com/ahmedfgad/GeneticAlgorithmPython/discussions/43 - A new
bool
attribute namedgene_type_single
is added to thepygad.GA
class. It isTrue
when there is a single data type assigned to thegene_type
parameter. When thegene_type
parameter is assigned alist/tuple/numpy.ndarray
, thengene_type_single
is set toFalse
. - The
mutation_by_replacement
flag now has no effect ifgene_space
exists except for the genes withNone
values. For example, forgene_space=[None, [5, 6]]
themutation_by_replacement
flag affects only the first gene which hasNone
for its value space. - When an element has a value of
None
in thegene_space
parameter (e.g.gene_space=[None, [5, 6]]
), then its value will be randomly generated for each solution rather than being generate once for all solutions. Previously, the gene withNone
value ingene_space
is the same across all solutions - Some changes in the documentation according to issue #32: https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/32
PyGAD 2.14.2¶
Release Date: 27 May 2021
- Some bug fixes when the
gene_type
parameter is nested. Thanks to Rainer Engel for opening a discussion to report this bug: https://github.com/ahmedfgad/GeneticAlgorithmPython/discussions/43#discussioncomment-763342
Rainer Engel helped a lot in suggesting new features and suggesting enhancements in 2.14.0 to 2.14.2 releases.
PyGAD 2.14.3¶
Release Date: 6 June 2021
- Some bug fixes when setting the
save_best_solutions
parameter toTrue
. Previously, the best solution for generationi
was added into thebest_solutions
attribute at generationi+1
. Now, thebest_solutions
attribute is updated by each best solution at its exact generation.
PyGAD 2.15.0¶
Release Date: 17 June 2021
- Control the precision of all genes/individual genes. Thanks to Rainer for asking about this feature: https://github.com/ahmedfgad/GeneticAlgorithmPython/discussions/43#discussioncomment-763452
- A new attribute named
last_generation_parents_indices
holds the indices of the selected parents in the last generation. - In adaptive mutation, no need to recalculate the fitness values of
the parents selected in the last generation as these values can be
returned based on the
last_generation_fitness
andlast_generation_parents_indices
attributes. This speeds-up the adaptive mutation. - When a sublist has a value of
None
in thegene_space
parameter (e.g.gene_space=[[1, 2, 3], [5, 6, None]]
), then its value will be randomly generated for each solution rather than being generated once for all solutions. Previously, a value ofNone
in a sublist of thegene_space
parameter was identical across all solutions. - The dictionary assigned to the
gene_space
parameter itself or one of its elements has a new key called"step"
to specify the step of moving from the start to the end of the range specified by the 2 existing keys"low"
and"high"
. An example is{"low": 0, "high": 30, "step": 2}
to have only even values for the gene(s) starting from 0 to 30. For more information, check the More about the ``gene_space` Parameter <https://pygad.readthedocs.io/en/latest/README_pygad_ReadTheDocs.html#more-about-the-gene-space-parameter>`__ section. https://github.com/ahmedfgad/GeneticAlgorithmPython/discussions/48 - A new function called
predict()
is added in both thepygad.kerasga
andpygad.torchga
modules to make predictions. This makes it easier than using custom code each time a prediction is to be made. - A new parameter called
stop_criteria
allows the user to specify one or more stop criteria to stop the evolution based on some conditions. Each criterion is passed asstr
which has a stop word. The current 2 supported words arereach
andsaturate
.reach
stops therun()
method if the fitness value is equal to or greater than a given fitness value. An example forreach
is"reach_40"
which stops the evolution if the fitness is >= 40.saturate
means stop the evolution if the fitness saturates for a given number of consecutive generations. An example forsaturate
is"saturate_7"
which means stop therun()
method if the fitness does not change for 7 consecutive generations. Thanks to Rainer for asking about this feature: https://github.com/ahmedfgad/GeneticAlgorithmPython/discussions/44 - A new bool parameter, defaults to
False
, namedsave_solutions
is added to the constructor of thepygad.GA
class. IfTrue
, then all solutions in each generation are appended into an attribute calledsolutions
which is NumPy array. - The
plot_result()
method is renamed toplot_fitness()
. The users should migrate to the new name as the old name will be removed in the future. - Four new optional parameters are added to the
plot_fitness()
function in thepygad.GA
class which arefont_size=14
,save_dir=None
,color="#3870FF"
, andplot_type="plot"
. Usefont_size
to change the font of the plot title and labels.save_dir
accepts the directory to which the figure is saved. It defaults toNone
which means do not save the figure.color
changes the color of the plot.plot_type
changes the plot type which can be either"plot"
(default),"scatter"
, or"bar"
. https://github.com/ahmedfgad/GeneticAlgorithmPython/pull/47 - The default value of the
title
parameter in theplot_fitness()
method is"PyGAD - Generation vs. Fitness"
rather than"PyGAD - Iteration vs. Fitness"
. - A new method named
plot_new_solution_rate()
creates, shows, and returns a figure showing the rate of new/unique solutions explored in each generation. It accepts the same parameters as in theplot_fitness()
method. This method only works whensave_solutions=True
in thepygad.GA
class’s constructor. - A new method named
plot_genes()
creates, shows, and returns a figure to show how each gene changes per each generation. It accepts similar parameters like theplot_fitness()
method in addition to thegraph_type
,fill_color
, andsolutions
parameters. Thegraph_type
parameter can be either"plot"
(default),"boxplot"
, or"histogram"
.fill_color
accepts the fill color which works whengraph_type
is either"boxplot"
or"histogram"
.solutions
can be either"all"
or"best"
to decide whether all solutions or only best solutions are used. - The
gene_type
parameter now supports controlling the precision offloat
data types. For a gene, rather than assigning just the data type likefloat
, assign alist
/tuple
/numpy.ndarray
with 2 elements where the first one is the type and the second one is the precision. For example,[float, 2]
forces a gene with a value like0.1234
to be0.12
. For more information, check the More about the ``gene_type` Parameter <https://pygad.readthedocs.io/en/latest/README_pygad_ReadTheDocs.html#more-about-the-gene-type-parameter>`__ section.
PyGAD 2.15.1¶
Release Date: 18 June 2021
- Fix a bug when
keep_parents
is set to a positive integer. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/49
PyGAD 2.15.2¶
Release Date: 18 June 2021
- Fix a bug when using the
kerasga
ortorchga
modules. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/51
PyGAD 2.16.0¶
Release Date: 19 June 2021
- A user-defined function can be passed to the
mutation_type
,crossover_type
, andparent_selection_type
parameters in thepygad.GA
class to create a custom mutation, crossover, and parent selection operators. Check the User-Defined Crossover, Mutation, and Parent Selection Operators section for more details. https://github.com/ahmedfgad/GeneticAlgorithmPython/discussions/50
PyGAD 2.16.1¶
Release Date: 28 September 2021
- The user can use the
tqdm
library to show a progress bar. https://github.com/ahmedfgad/GeneticAlgorithmPython/discussions/50.
import pygad
import numpy
import tqdm
equation_inputs = [4,-2,3.5]
desired_output = 44
def fitness_func(solution, solution_idx):
output = numpy.sum(solution * equation_inputs)
fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
return fitness
num_generations = 10000
with tqdm.tqdm(total=num_generations) as pbar:
ga_instance = pygad.GA(num_generations=num_generations,
sol_per_pop=5,
num_parents_mating=2,
num_genes=len(equation_inputs),
fitness_func=fitness_func,
on_generation=lambda _: pbar.update(1))
ga_instance.run()
ga_instance.plot_result()
But this work does not work if the ga_instance
will be pickled (i.e.
the save()
method will be called.
ga_instance.save("test")
To solve this issue, define a function and pass it to the
on_generation
parameter. In the next code, the
on_generation_progress()
function is defined which updates the
progress bar.
import pygad
import numpy
import tqdm
equation_inputs = [4,-2,3.5]
desired_output = 44
def fitness_func(solution, solution_idx):
output = numpy.sum(solution * equation_inputs)
fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
return fitness
def on_generation_progress(ga):
pbar.update(1)
num_generations = 100
with tqdm.tqdm(total=num_generations) as pbar:
ga_instance = pygad.GA(num_generations=num_generations,
sol_per_pop=5,
num_parents_mating=2,
num_genes=len(equation_inputs),
fitness_func=fitness_func,
on_generation=on_generation_progress)
ga_instance.run()
ga_instance.plot_result()
ga_instance.save("test")
- Solved the issue of unequal length between the
solutions
andsolutions_fitness
when thesave_solutions
parameter is set toTrue
. Now, the fitness of the last population is appended to thesolutions_fitness
array. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/64 - There was an issue of getting the length of these 4 variables
(
solutions
,solutions_fitness
,best_solutions
, andbest_solutions_fitness
) doubled after each call of therun()
method. This is solved by resetting these variables at the beginning of therun()
method. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/62 - Bug fixes when adaptive mutation is used
(
mutation_type="adaptive"
). https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/65
PyGAD 2.16.2¶
Release Date: 2 February 2022
- A new instance attribute called
previous_generation_fitness
added in thepygad.GA
class. It holds the fitness values of one generation before the fitness values saved in thelast_generation_fitness
. - Issue in the
cal_pop_fitness()
method in getting the correct indices of the previous parents. This is solved by using the previous generation’s fitness saved in the new attributeprevious_generation_fitness
to return the parents’ fitness values. Thanks to Tobias Tischhauser (M.Sc. - Mitarbeiter Institut EMS, Departement Technik, OST – Ostschweizer Fachhochschule, Switzerland) for detecting this bug.
PyGAD 2.16.3¶
Release Date: 2 February 2022
- Validate the fitness value returned from the fitness function. An exception is raised if something is wrong. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/67
PyGAD 2.17.0¶
Release Date: 8 July 2022
- An issue is solved when the
gene_space
parameter is given a fixed value. e.g. gene_space=[range(5), 4]. The second gene’s value is static (4) which causes an exception. - Fixed the issue where the
allow_duplicate_genes
parameter did not work when mutation is disabled (i.e.mutation_type=None
). This is by checking for duplicates after crossover directly. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/39 - Solve an issue in the
tournament_selection()
method as the indices of the selected parents were incorrect. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/89 - Reuse the fitness values of the previously explored solutions rather
than recalculating them. This feature only works if
save_solutions=True
. - Parallel processing is supported. This is by the introduction of a
new parameter named
parallel_processing
in the constructor of thepygad.GA
class. Thanks to @windowshopr for opening the issue #78 at GitHub. Check the Parallel Processing in PyGAD section for more information and examples.
PyGAD 2.18.0¶
Release Date: 9 September 2022
- Raise an exception if the sum of fitness values is zero while either roulette wheel or stochastic universal parent selection is used. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/129
- Initialize the value of the
run_completed
property toFalse
. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/122 - The values of these properties are no longer reset with each call to
the
run()
methodself.best_solutions, self.best_solutions_fitness, self.solutions, self.solutions_fitness
: https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/123. Now, the user can have the flexibility of calling therun()
method more than once while extending the data collected after each generation. Another advantage happens when the instance is loaded and therun()
method is called, as the old fitness value are shown on the graph alongside with the new fitness values. Read more in this section: Continue without Loosing Progress - Thanks Prof. Fernando Jiménez Barrionuevo (Dept. of Information and Communications Engineering, University of Murcia, Murcia, Spain) for editing this comment in the code. https://github.com/ahmedfgad/GeneticAlgorithmPython/commit/5315bbec02777df96ce1ec665c94dece81c440f4
- A bug fixed when
crossover_type=None
. - Support of elitism selection through a new parameter named
keep_elitism
. It defaults to 1 which means for each generation keep only the best solution in the next generation. If assigned 0, then it has no effect. Read more in this section: Elitism Selection. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/74 - A new instance attribute named
last_generation_elitism
added to hold the elitism in the last generation. - A new parameter called
random_seed
added to accept a seed for the random function generators. Credit to this issue https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/70 and Prof. Fernando Jiménez Barrionuevo. Read more in this section: Random Seed. - Editing the
pygad.TorchGA
module to make sure the tensor data is moved from GPU to CPU. Thanks to Rasmus Johansson for opening this pull request: https://github.com/ahmedfgad/TorchGA/pull/2
PyGAD 2.18.1¶
Release Date: 19 September 2022
- A big fix when
keep_elitism
is used. https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/132
PyGAD Projects at GitHub¶
The PyGAD library is available at PyPI at this page https://pypi.org/project/pygad. PyGAD is built out of a number of open-source GitHub projects. A brief note about these projects is given in the next subsections.
GeneticAlgorithmPython¶
GitHub Link: https://github.com/ahmedfgad/GeneticAlgorithmPython
GeneticAlgorithmPython is the first project which is an open-source Python 3 project for implementing the genetic algorithm based on NumPy.
NumPyANN¶
GitHub Link: https://github.com/ahmedfgad/NumPyANN
NumPyANN builds artificial neural networks in Python 3 using NumPy from scratch. The purpose of this project is to only implement the forward pass of a neural network without using a training algorithm. Currently, it only supports classification and later regression will be also supported. Moreover, only one class is supported per sample.
NeuralGenetic¶
GitHub Link: https://github.com/ahmedfgad/NeuralGenetic
NeuralGenetic trains neural networks using the genetic algorithm based on the previous 2 projects GeneticAlgorithmPython and NumPyANN.
NumPyCNN¶
GitHub Link: https://github.com/ahmedfgad/NumPyCNN
NumPyCNN builds convolutional neural networks using NumPy. The purpose of this project is to only implement the forward pass of a convolutional neural network without using a training algorithm.
CNNGenetic¶
GitHub Link: https://github.com/ahmedfgad/CNNGenetic
CNNGenetic trains convolutional neural networks using the genetic algorithm. It uses the GeneticAlgorithmPython project for building the genetic algorithm.
KerasGA¶
GitHub Link: https://github.com/ahmedfgad/KerasGA
KerasGA trains Keras models using the genetic algorithm. It uses the GeneticAlgorithmPython project for building the genetic algorithm.
TorchGA¶
GitHub Link: https://github.com/ahmedfgad/TorchGA
TorchGA trains PyTorch models using the genetic algorithm. It uses the GeneticAlgorithmPython project for building the genetic algorithm.
Stackoverflow Questions about PyGAD¶
Submitting Issues¶
If there is an issue using PyGAD, then use any of your preferred option to discuss that issue.
One way is submitting an issue into this GitHub project (github.com/ahmedfgad/GeneticAlgorithmPython) in case something is not working properly or to ask for questions.
If this is not a proper option for you, then check the Contact Us section for more contact details.
Ask for Feature¶
PyGAD is actively developed with the goal of building a dynamic library for suporting a wide-range of problems to be optimized using the genetic algorithm.
To ask for a new feature, either submit an issue into this GitHub project (github.com/ahmedfgad/GeneticAlgorithmPython) or send an e-mail to ahmed.f.gad@gmail.com.
Also check the Contact Us section for more contact details.
Projects Built using PyGAD¶
If you created a project that uses PyGAD, then we can support you by mentioning this project here in PyGAD’s documentation.
To do that, please send a message at ahmed.f.gad@gmail.com or check the Contact Us section for more contact details.
Within your message, please send the following details:
- Project title
- Brief description
- Preferably, a link that directs the readers to your project
Tutorials about PyGAD¶
Adaptive Mutation in Genetic Algorithm with Python Examples¶
In this tutorial, we’ll see why mutation with a fixed number of genes is bad, and how to replace it with adaptive mutation. Using the PyGAD Python 3 library, we’ll discuss a few examples that use both random and adaptive mutation.
Clustering Using the Genetic Algorithm in Python¶
This tutorial discusses how the genetic algorithm is used to cluster data, starting from random clusters and running until the optimal clusters are found. We’ll start by briefly revising the K-means clustering algorithm to point out its weak points, which are later solved by the genetic algorithm. The code examples in this tutorial are implemented in Python using the PyGAD library.
Working with Different Genetic Algorithm Representations in Python¶
Depending on the nature of the problem being optimized, the genetic algorithm (GA) supports two different gene representations: binary, and decimal. The binary GA has only two values for its genes, which are 0 and 1. This is easier to manage as its gene values are limited compared to the decimal GA, for which we can use different formats like float or integer, and limited or unlimited ranges.
This tutorial discusses how the PyGAD library supports the two GA representations, binary and decimal.
5 Genetic Algorithm Applications Using PyGAD¶
This tutorial introduces PyGAD, an open-source Python library for implementing the genetic algorithm and training machine learning algorithms. PyGAD supports 19 parameters for customizing the genetic algorithm for various applications.
Within this tutorial we’ll discuss 5 different applications of the genetic algorithm and build them using PyGAD.
Train Neural Networks Using a Genetic Algorithm in Python with PyGAD¶
The genetic algorithm (GA) is a biologically-inspired optimization algorithm. It has in recent years gained importance, as it’s simple while also solving complex problems like travel route optimization, training machine learning algorithms, working with single and multi-objective problems, game playing, and more.
Deep neural networks are inspired by the idea of how the biological brain works. It’s a universal function approximator, which is capable of simulating any function, and is now used to solve the most complex problems in machine learning. What’s more, they’re able to work with all types of data (images, audio, video, and text).
Both genetic algorithms (GAs) and neural networks (NNs) are similar, as both are biologically-inspired techniques. This similarity motivates us to create a hybrid of both to see whether a GA can train NNs with high accuracy.
This tutorial uses PyGAD, a Python library that supports building and training NNs using a GA. PyGAD offers both classification and regression NNs.
Building a Game-Playing Agent for CoinTex Using the Genetic Algorithm¶
In this tutorial we’ll see how to build a game-playing agent using only the genetic algorithm to play a game called CoinTex, which is developed in the Kivy Python framework. The objective of CoinTex is to collect the randomly distributed coins while avoiding collision with fire and monsters (that move randomly). The source code of CoinTex can be found on GitHub.
The genetic algorithm is the only AI used here; there is no other machine/deep learning model used with it. We’ll implement the genetic algorithm using PyGad. This tutorial starts with a quick overview of CoinTex followed by a brief explanation of the genetic algorithm, and how it can be used to create the playing agent. Finally, we’ll see how to implement these ideas in Python.
The source code of the genetic algorithm agent is available here, and you can download the code used in this tutorial from here.
How To Train Keras Models Using the Genetic Algorithm with PyGAD¶
PyGAD is an open-source Python library for building the genetic algorithm and training machine learning algorithms. It offers a wide range of parameters to customize the genetic algorithm to work with different types of problems.
PyGAD has its own modules that support building and training neural networks (NNs) and convolutional neural networks (CNNs). Despite these modules working well, they are implemented in Python without any additional optimization measures. This leads to comparatively high computational times for even simple problems.
The latest PyGAD version, 2.8.0 (released on 20 September 2020), supports a new module to train Keras models. Even though Keras is built in Python, it’s fast. The reason is that Keras uses TensorFlow as a backend, and TensorFlow is highly optimized.
This tutorial discusses how to train Keras models using PyGAD. The discussion includes building Keras models using either the Sequential Model or the Functional API, building an initial population of Keras model parameters, creating an appropriate fitness function, and more.
Train PyTorch Models Using Genetic Algorithm with PyGAD¶
PyGAD is a genetic algorithm Python 3 library for solving optimization problems. One of these problems is training machine learning algorithms.
PyGAD has a module called pygad.kerasga. It trains Keras models using the genetic algorithm. On January 3rd, 2021, a new release of PyGAD 2.10.0 brought a new module called pygad.torchga to train PyTorch models. It’s very easy to use, but there are a few tricky steps.
So, in this tutorial, we’ll explore how to use PyGAD to train PyTorch models.
PyGAD in Other Languages¶
French¶
Cómo los algoritmos genéticos pueden competir con el descenso de gradiente y el backprop
Bien que la manière standard d’entraîner les réseaux de neurones soit la descente de gradient et la rétropropagation, il y a d’autres joueurs dans le jeu. L’un d’eux est les algorithmes évolutionnaires, tels que les algorithmes génétiques.
Utiliser un algorithme génétique pour former un réseau de neurones simple pour résoudre le OpenAI CartPole Jeu. Dans cet article, nous allons former un simple réseau de neurones pour résoudre le OpenAI CartPole . J’utiliserai PyTorch et PyGAD .
Spanish¶
Cómo los algoritmos genéticos pueden competir con el descenso de gradiente y el backprop
Aunque la forma estandar de entrenar redes neuronales es el descenso de gradiente y la retropropagacion, hay otros jugadores en el juego, uno de ellos son los algoritmos evolutivos, como los algoritmos geneticos.
Usa un algoritmo genetico para entrenar una red neuronal simple para resolver el Juego OpenAI CartPole. En este articulo, entrenaremos una red neuronal simple para resolver el OpenAI CartPole . Usare PyTorch y PyGAD .
Korean¶
[PyGAD] Python 에서 Genetic Algorithm 을 사용해보기¶
파이썬에서 genetic algorithm을 사용하는 패키지들을 다 사용해보진 않았지만, 확장성이 있어보이고, 시도할 일이 있어서 살펴봤다.
이 패키지에서 가장 인상 깊었던 것은 neural network에서 hyper parameter 탐색을 gradient descent 방식이 아닌 GA로도 할 수 있다는 것이다.
개인적으로 이 부분이 어느정도 초기치를 잘 잡아줄 수 있는 역할로도 쓸 수 있고, Loss가 gradient descent 하기 어려운 구조에서 대안으로 쓸 수 있을 것으로도 생각된다.
일단 큰 흐름은 다음과 같이 된다.
사실 완전히 흐름이나 각 parameter에 대한 이해는 부족한 상황
Turkish¶
PyGAD ile Genetik Algoritmayı Kullanarak Keras Modelleri Nasıl Eğitilir¶
This is a translation of an original English tutorial published at Paperspace: How To Train Keras Models Using the Genetic Algorithm with PyGAD
PyGAD, genetik algoritma oluşturmak ve makine öğrenimi algoritmalarını eğitmek için kullanılan açık kaynaklı bir Python kitaplığıdır. Genetik algoritmayı farklı problem türleri ile çalışacak şekilde özelleştirmek için çok çeşitli parametreler sunar.
PyGAD, sinir ağları (NN’ler) ve evrişimli sinir ağları (CNN’ler) oluşturmayı ve eğitmeyi destekleyen kendi modüllerine sahiptir. Bu modüllerin iyi çalışmasına rağmen, herhangi bir ek optimizasyon önlemi olmaksızın Python’da uygulanırlar. Bu, basit problemler için bile nispeten yüksek hesaplama sürelerine yol açar.
En son PyGAD sürümü 2.8.0 (20 Eylül 2020’de piyasaya sürüldü), Keras modellerini eğitmek için yeni bir modülü destekliyor. Keras Python’da oluşturulmuş olsa da hızlıdır. Bunun nedeni, Keras’ın arka uç olarak TensorFlow kullanması ve TensorFlow’un oldukça optimize edilmiş olmasıdır.
Bu öğreticide, PyGAD kullanılarak Keras modellerinin nasıl eğitileceği anlatılmaktadır. Tartışma, Sıralı Modeli veya İşlevsel API’yi kullanarak Keras modellerini oluşturmayı, Keras model parametrelerinin ilk popülasyonunu oluşturmayı, uygun bir uygunluk işlevi oluşturmayı ve daha fazlasını içerir.
Hungarian¶
Tensorflow alapozó 10. Neurális hálózatok tenyésztése genetikus algoritmussal PyGAD és OpenAI Gym használatával¶
Hogy kontextusba helyezzem a genetikus algoritmusokat, ismételjük kicsit át, hogy hogyan működik a gradient descent és a backpropagation, ami a neurális hálók tanításának általános módszere. Az erről írt cikkemet itt tudjátok elolvasni.
A hálózatok tenyésztéséhez a PyGAD nevű programkönyvtárat használjuk, így mindenek előtt ezt kell telepítenünk, valamint a Tensorflow-t és a Gym-et, amit Colabban már eleve telepítve kapunk.
Maga a PyGAD egy teljesen általános genetikus algoritmusok futtatására képes rendszer. Ennek a kiterjesztése a KerasGA, ami az általános motor Tensorflow (Keras) neurális hálókon történő futtatását segíti. A 47. sorban létrehozott KerasGA objektum ennek a kiterjesztésnek a része és arra szolgál, hogy a paraméterként átadott modellből a második paraméterben megadott számosságú populációt hozzon létre. Mivel a hálózatunk 386 állítható paraméterrel rendelkezik, ezért a DNS-ünk itt 386 elemből fog állni. A populáció mérete 10 egyed, így a kezdő populációnk egy 10x386 elemű mátrix lesz. Ezt adjuk át az 51. sorban az initial_population paraméterben.
Russian¶
PyGAD: библиотека для имплементации генетического алгоритма¶
PyGAD — это библиотека для имплементации генетического алгоритма. Кроме того, библиотека предоставляет доступ к оптимизированным реализациям алгоритмов машинного обучения. PyGAD разрабатывали на Python 3.
Библиотека PyGAD поддерживает разные типы скрещивания, мутации и селекции родителя. PyGAD позволяет оптимизировать проблемы с помощью генетического алгоритма через кастомизацию целевой функции.
Кроме генетического алгоритма, библиотека содержит оптимизированные имплементации алгоритмов машинного обучения. На текущий момент PyGAD поддерживает создание и обучение нейросетей для задач классификации.
Библиотека находится в стадии активной разработки. Создатели планируют добавление функционала для решения бинарных задач и имплементации новых алгоритмов.
PyGAD разрабатывали на Python 3.7.3. Зависимости включают в себя NumPy для создания и манипуляции массивами и Matplotlib для визуализации. Один из изкейсов использования инструмента — оптимизация весов, которые удовлетворяют заданной функции.
Research Papers using PyGAD¶
A number of research papers used PyGAD and here are some of them:
- Jaros, Marta, and Jiri Jaros. “Performance-Cost Optimization of Moldable Scientific Workflows.”
- Thorat, Divya. “Enhanced genetic algorithm to reduce makespan of multiple jobs in map-reduce application on serverless platform”. Diss. Dublin, National College of Ireland, 2020.
- Koch, Chris, and Edgar Dobriban. “AttenGen: Generating Live Attenuated Vaccine Candidates using Machine Learning.” (2021).
- Bhardwaj, Bhavya, et al. “Windfarm optimization using Nelder-Mead and Particle Swarm optimization.” 2021 7th International Conference on Electrical Energy Systems (ICEES). IEEE, 2021.
- Bernardo, Reginald Christian S. and J. Said. “Towards a model-independent reconstruction approach for late-time Hubble data.” (2021).
- Duong, Tri Dung, Qian Li, and Guandong Xu. “Prototype-based Counterfactual Explanation for Causal Classification.” arXiv preprint arXiv:2105.00703 (2021).
- Farrag, Tamer Ahmed, and Ehab E. Elattar. “Optimized Deep Stacked Long Short-Term Memory Network for Long-Term Load Forecasting.” IEEE Access 9 (2021): 68511-68522.
- Antunes, E. D. O., Caetano, M. F., Marotta, M. A., Araujo, A., Bondan, L., Meneguette, R. I., & Rocha Filho, G. P. (2021, August). Soluções Otimizadas para o Problema de Localização de Máxima Cobertura em Redes Militarizadas 4G/LTE. In Anais do XXVI Workshop de Gerência e Operação de Redes e Serviços (pp. 152-165). SBC.
- M. Yani, F. Ardilla, A. A. Saputra and N. Kubota, “Gradient-Free Deep Q-Networks Reinforcement learning: Benchmark and Evaluation,” 2021 IEEE Symposium Series on Computational Intelligence (SSCI), 2021, pp. 1-5, doi: 10.1109/SSCI50451.2021.9659941.
- Yani, Mohamad, and Naoyuki Kubota. “Deep Convolutional Networks with Genetic Algorithm for Reinforcement Learning Problem.”
- Mahendra, Muhammad Ihza, and Isman Kurniawan. “Optimizing Convolutional Neural Network by Using Genetic Algorithm for COVID-19 Detection in Chest X-Ray Image.” 2021 International Conference on Data Science and Its Applications (ICoDSA). IEEE, 2021.
- Glibota, Vjeko. Umjeravanje mikroskopskog prometnog modela primjenom genetskog algoritma. Diss. University of Zagreb. Faculty of Transport and Traffic Sciences. Division of Intelligent Transport Systems and Logistics. Department of Intelligent Transport Systems, 2021.
- Zhu, Mingda. Genetic Algorithm-based Parameter Identification for Ship Manoeuvring Model under Wind Disturbance. MS thesis. NTNU, 2021.
- Abdalrahman, Ahmed, and Weihua Zhuang. “Dynamic pricing for differentiated pev charging services using deep reinforcement learning.” IEEE Transactions on Intelligent Transportation Systems (2020).
For More Information¶
There are different resources that can be used to get started with the genetic algorithm and building it in Python.
Tutorial: Implementing Genetic Algorithm in Python¶
To start with coding the genetic algorithm, you can check the tutorial titled Genetic Algorithm Implementation in Python available at these links:
This tutorial is prepared based on a previous version of the project but it still a good resource to start with coding the genetic algorithm.
Tutorial: Introduction to Genetic Algorithm¶
Get started with the genetic algorithm by reading the tutorial titled Introduction to Optimization with Genetic Algorithm which is available at these links:
Tutorial: Build Neural Networks in Python¶
Read about building neural networks in Python through the tutorial titled Artificial Neural Network Implementation using NumPy and Classification of the Fruits360 Image Dataset available at these links:
Tutorial: Optimize Neural Networks with Genetic Algorithm¶
Read about training neural networks using the genetic algorithm through the tutorial titled Artificial Neural Networks Optimization using Genetic Algorithm with Python available at these links:
Tutorial: Building CNN in Python¶
To start with coding the genetic algorithm, you can check the tutorial titled Building Convolutional Neural Network using NumPy from Scratch available at these links:
This tutorial) is prepared based on a previous version of the project but it still a good resource to start with coding CNNs.
Tutorial: Derivation of CNN from FCNN¶
Get started with the genetic algorithm by reading the tutorial titled Derivation of Convolutional Neural Network from Fully Connected Network Step-By-Step which is available at these links:
Book: Practical Computer Vision Applications Using Deep Learning with CNNs¶
You can also check my book cited as Ahmed Fawzy Gad ‘Practical Computer Vision Applications Using Deep Learning with CNNs’. Dec. 2018, Apress, 978-1-4842-4167-7 which discusses neural networks, convolutional neural networks, deep learning, genetic algorithm, and more.
Find the book at these links:

Contact Us¶
- E-mail: ahmed.f.gad@gmail.com
- Amazon Author Page
- Heartbeat
- Paperspace
- KDnuggets
- TowardsDataScience
- GitHub

Thank you for using PyGAD :)