# coding=utf-8
"""
.. moduleauthor:: Shuhua Gao
This :mod:`basic` module provides fundamental boilerplate GEP algorithm implementations. After registering proper
operations into a :class:`deap.base.Toolbox` object, the GEP evolution can be simply launched using the present
algorithms. Of course, for complicated problems, you may want to define your own algorithms, and the implementation here
can be used as a reference.
"""
import deap
import random
import warnings
def _validate_basic_toolbox(tb):
"""
Validate the operators in the toolbox *tb* according to our conventions.
"""
assert hasattr(tb, 'select'), "The toolbox must have a 'select' operator."
# whether the ops in .pbs are all registered
for op in tb.pbs:
assert op.startswith('mut') or op.startswith('cx'), "Operators must start with 'mut' or 'cx' except selection."
assert hasattr(tb, op), "Probability for a operator called '{}' is specified, but this operator is not " \
"registered in the toolbox.".format(op)
# whether all the mut_ and cx_ operators have their probabilities assigned in .pbs
for op in [attr for attr in dir(tb) if attr.startswith('mut') or attr.startswith('cx')]:
if op not in tb.pbs:
warnings.warn('{0} is registered, but its probability is NOT assigned in Toolbox.pbs. '
'By default, the probability is ZERO and the operator {0} will NOT be applied.'.format(op),
category=UserWarning)
def _apply_modification(population, operator, pb):
"""
Apply the modification given by *operator* to each individual in *population* with probability *pb* in place.
"""
for i in range(len(population)):
if random.random() < pb:
population[i], = operator(population[i])
del population[i].fitness.values
return population
def _apply_crossover(population, operator, pb):
"""
Mate the *population* in place using *operator* with probability *pb*.
"""
for i in range(1, len(population), 2):
if random.random() < pb:
population[i - 1], population[i] = operator(population[i - 1], population[i])
del population[i - 1].fitness.values
del population[i].fitness.values
return population
[docs]def gep_simple(population, toolbox, n_generations=100, n_elites=1,
stats=None, hall_of_fame=None, verbose=__debug__):
"""
This algorithm performs the simplest and standard gene expression programming.
The flowchart of this algorithm can be found
`here <https://www.gepsoft.com/gxpt4kb/Chapter06/Section1/SS1.htm>`_.
Refer to Chapter 3 of [FC2006]_ to learn more about this basic algorithm.
.. note::
The algorithm framework also supports the GEP-RNC algorithm, which evolves genes with an additional Dc domain for
random numerical constant manipulation. To adopt :func:`gep_simple` for GEP-RNC evolution, use the
:class:`~geppy.core.entity.GeneDc` objects as the genes and register Dc-specific operators.
A detailed example of GEP-RNC can be found at `numerical expression inference with GEP-RNC
<https://github.com/ShuhuaGao/geppy/blob/master/examples/sr/numerical_expression_inference-RNC.ipynb>`_.
Users can refer to Chapter 5 of [FC2006]_ to get familiar with the GEP-RNC theory.
:param population: a list of individuals
:param toolbox: :class:`~geppy.tools.toolbox.Toolbox`, a container of operators. Regarding the conventions of
operator design and registration, please refer to :ref:`convention`.
:param n_generations: max number of generations to be evolved
:param n_elites: number of elites to be cloned to next generation
:param stats: a :class:`~deap.tools.Statistics` object that is updated
inplace, optional.
:param hall_of_fame: a :class:`~deap.tools.HallOfFame` object that will
contain the best individuals, optional.
:param verbose: whether or not to print the statistics.
:returns: The final population
:returns: A :class:`~deap.tools.Logbook` recording the statistics of the
evolution process
.. note:
To implement the GEP-RNC algorithm for numerical constant evolution, the :class:`geppy.core.entity.GeneDc` genes
should be used. Specific operators are used to evolve the Dc domain of :class:`~geppy.core.entity.GeneDc` genes
including Dc-specific mutation/inversion/transposition and direct mutation of the RNC array associated with
each gene. These operators should be registered into the *toolbox*.
"""
_validate_basic_toolbox(toolbox)
logbook = deap.tools.Logbook()
logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])
for gen in range(n_generations + 1):
# evaluate: only evaluate the invalid ones, i.e., no need to reevaluate the unchanged ones
invalid_individuals = [ind for ind in population if not ind.fitness.valid]
fitnesses = toolbox.map(toolbox.evaluate, invalid_individuals)
for ind, fit in zip(invalid_individuals, fitnesses):
ind.fitness.values = fit
# record statistics and log
if hall_of_fame is not None:
hall_of_fame.update(population)
record = stats.compile(population) if stats else {}
logbook.record(gen=gen, nevals=len(invalid_individuals), **record)
if verbose:
print(logbook.stream)
if gen == n_generations:
break
# selection with elitism
elites = deap.tools.selBest(population, k=n_elites)
offspring = toolbox.select(population, len(population) - n_elites)
# replication
offspring = [toolbox.clone(ind) for ind in offspring]
# mutation
for op in toolbox.pbs:
if op.startswith('mut'):
offspring = _apply_modification(offspring, getattr(toolbox, op), toolbox.pbs[op])
# crossover
for op in toolbox.pbs:
if op.startswith('cx'):
offspring = _apply_crossover(offspring, getattr(toolbox, op), toolbox.pbs[op])
# replace the current population with the offsprings
population = elites + offspring
return population, logbook
__all__ = ['gep_simple']
Project Homepage