Fully Configurable EA Implementation with Selection and Fitness Assignment

Author: thomasWeise

moptipy/algorithms/modules/selection.py

@@ -38,6 +38,13 @@ def select(self, source: List[FitnessRecord], dest: List[FitnessRecord],
         only the :attr:`~FitnessRecord.fitness` attribute of the records and
         the random numbers from `random` should be used as decision criteria.
 
+        Selection algorithms are modules of the fully-configurable
+        Evolutionary Algorithm :class:`~moptipy.algorithms.so.full_ea.FullEA`.
+        They can utilize fitness values computed by the fitness assignment
+        processes (:class:`~moptipy.algorithms.so.fitness.Fitness`). Of
+        course, they can also be applied in different contexts and are not
+        bound to single-objective optimization.
+
         :param source: the list with the records to select from
         :param dest: the destination to append the selected records to
         :param n: the number of records to select

moptipy/algorithms/modules/selections/best.py

@@ -0,0 +1,78 @@
+"""
+Choose the `n` best elements from the source array.
+
+"Best" selection is the standard way to perform survival selection in a
+(mu+lambda) Evolutionary Algorithm (:class:`~moptipy.algorithms.so.ea.EA`).
+It basically sorts the input array based on fitness and then copies the first
+`n` elements to the output array. The algorithm is not random but
+deterministic, i.e., it will always select each of the `n` best records
+exactly once.
+
+This selection is also often called "mu+lambda," "mu,lambda," or "top-n"
+selection. It is similar to the selection scheme in Eshelman's CHC algorithm.
+A randomized version of this algorithm is called "truncation selection" in the
+paper of Blickle and Thiele.
+
+1. Peter J. B. Hancock. An Empirical Comparison of Selection Methods in
+   Evolutionary Algorithms. In Terence Claus Fogarty, editor, *Selected Papers
+   from the AISB Workshop on Evolutionary Computing (AISB EC'94),* April
+   11-13, 1994, Leeds, UK, volume 865 of Lecture Notes in Computer Science,
+   pages 80-94, Berlin/Heidelberg, Germany: Springer, ISBN: 978-3-540-58483-4.
+   https://dx.doi.org/10.1007/3-540-58483-8_7. Conference organized by the
+   Society for the Study of Artificial Intelligence and Simulation of
+   Behaviour (AISB).
+2. Larry J.Eshelman. The CHC Adaptive Search Algorithm: How to Have Safe
+   Search When Engaging in Nontraditional Genetic Recombination. In Gregory
+   J. E. Rawlins, editor, Foundations of Genetic Algorithms, volume 1, 1991,
+   pages 265-283. San Francisco, CA: Morgan Kaufmann.
+   https://doi.org/10.1016/B978-0-08-050684-5.50020-3
+3. Frank Hoffmeister and Thomas Bäck. Genetic Algorithms and Evolution
+   Strategies: Similarities and Differences. In Hans-Paul Schwefel and
+   Reinhard Männer, *Proceedings of the International Conference on Parallel
+   Problem Solving from Nature (PPSN I),* October 1-3, 1990, Dortmund,
+   Germany, volume 496 of Lecture Notes in Computer Science, pages 455-469,
+   Berlin/Heidelberg, Germany: Springer. ISBN: 978-3-540-54148-6.
+   https://doi.org/10.1007/BFb0029787.
+4. Uday Kumar Chakraborty and Kalyanmoy Deb and Mandira Chakraborty. Analysis
+   of Selection Algorithms: A Markov Chain Approach. *Evolutionary
+   Computation,* 4(2):133-167. Summer 1996. Cambridge, MA, USA: MIT Press.
+   doi:10.1162/evco.1996.4.2.133.
+   https://dl.acm.org/doi/pdf/10.1162/evco.1996.4.2.133
+5. Tobias Blickle and Lothar Thiele. A Comparison of Selection Schemes used in
+   Genetic Algorithms. Second edition, December 1995. TIK-Report 11 from the
+   Eidgenössische Technische Hochschule (ETH) Zürich, Department of Electrical
+   Engineering, Computer Engineering and Networks Laboratory (TIK), Zürich,
+   Switzerland. ftp://ftp.tik.ee.ethz.ch/pub/publications/TIK-Report11.ps
+"""
+
+from typing import List
+
+from numpy.random import Generator
+
+
+from moptipy.algorithms.modules.selection import Selection, FitnessRecord
+
+
+class Best(Selection):
+    """The best selection: select each of the best `n` elements once."""
+
+    def select(self, source: List[FitnessRecord], dest: List[FitnessRecord],
+               n: int, random: Generator) -> None:  # pylint: disable=W0613
+        """
+        Perform deterministic best selection without replacement.
+
+        :param source: the list with the records to select from
+        :param dest: the destination to append the selected records to
+        :param n: the number of records to select
+        :param random: the random number generator
+        """
+        source.sort()
+        dest.extend(source[0:n])
+
+    def __str__(self):
+        """
+        Get the name of the best selection algorithm.
+
+        :return: the name of the best selection algorithm
+        """
+        return "trunc"

moptipy/algorithms/modules/selections/truncation.py

@@ -39,6 +39,13 @@
    Estimation, Simulation, and Control - Wiley-Interscience Series in Discrete
    Mathematics and Optimization, volume 6. 2003. Chichester, West Sussex, UK:
    Wiley Interscience. ISBN: 0-471-33052-3. http://www.jhuapl.edu/ISSO/.
+3. Frank Hoffmeister and Thomas Bäck. Genetic Algorithms and Evolution
+   Strategies: Similarities and Differences. In Hans-Paul Schwefel and
+   Reinhard Männer, *Proceedings of the International Conference on Parallel
+   Problem Solving from Nature (PPSN I),* October 1-3, 1990, Dortmund,
+   Germany, volume 496 of Lecture Notes in Computer Science, pages 455-469,
+   Berlin/Heidelberg, Germany: Springer. ISBN: 978-3-540-54148-6.
+   https://doi.org/10.1007/BFb0029787.
 """
 from math import isfinite
 from typing import Final, Union, Callable, List, cast, Optional

moptipy/algorithms/so/ea.py

@@ -1 +1,8 @@
-"""Fitness assignment processes."""
+"""
+Fitness assignment processes.
+
+Fitness assignment processes are modules of the fully-configurable
+Evolutionary Algorithm :class:`~moptipy.algorithms.so.full_ea.FullEA`.
+The transform objective values to scalar fitness values that are then used
+by :class:`~moptipy.algorithms.modules.selection.Selection` algorithms.
+"""

moptipy/algorithms/so/fitnesses/__init__.py

@@ -0,0 +1,40 @@
+"""Use the objective values directly as fitness."""
+
+from typing import List
+
+from numpy.random import Generator
+
+from moptipy.algorithms.so.fitness import Fitness, FRecord
+
+
+class Direct(Fitness):
+    """
+    Objective values are used as fitness directly.
+
+    This is the most primitive and basic fitness assignment strategy.
+    It does not give preference to new solutions over old solutions if both
+    have the same objective value. In this, it is different from
+    :class:`~moptipy.algorithms.so.fitnesses.rank_and_iteration\
+.RankAndIteration`, which is the default fitness assignment strategy.
+    It is therefore also not compatible to our basic (mu+lambda) Evolutionary
+    Algorithm implementation (:class:`~moptipy.algorithms.so.ea.EA`).
+    """
+
+    def assign_fitness(self, p: List[FRecord], random: Generator) -> None:
+        """
+        Assign the objective value as fitness.
+
+        :param p: the list of records
+        :param random: ignored
+        """
+        for rec in p:
+            rec.fitness = rec.f
+
+    def __str__(self):
+        """
+        Get the name of this direct fitness assignment.
+
+        :return: the name of this fitness assignment strategy
+        :retval "direct": always
+        """
+        return "direct"

moptipy/algorithms/so/fitnesses/direct.py

@@ -12,8 +12,8 @@
 into the fitness.
 This index is used to break ties, in which case newer solutions are preferred.
 This can make the EA with FFA compatible with the
-:class:`moptipy.algorithms.so.fea1plus1.FEA1plus1` if truncation selection
-(:class:`moptipy.algorithms.modules.selections.truncation.Truncation`) is used
+:class:`moptipy.algorithms.so.fea1plus1.FEA1plus1` if "best" selection
+(:class:`moptipy.algorithms.modules.selections.best.Best`) is used
 at mu=lambda=1.
 
 1. Thomas Weise, Zhize Wu, Xinlu Li, and Yan Chen. Frequency Fitness

moptipy/algorithms/so/fitnesses/ffa.py

@@ -38,8 +38,8 @@ class RankAndIteration(Fitness):
 
     This way, better solutions receive better fitness and ties are broken such
     that younger solutions (with higher iteration index) are preferred.
-    In combination with truncation selection
-    (:class:`moptipy.algorithms.modules.selections.truncation.Truncation`),
+    In combination with best selection
+    (:class:`moptipy.algorithms.modules.selections.best.Best`),
     this replicates the behavior of our simple (mu+lambda) Evolutionary
     Algorithm (:class:`~moptipy.algorithms.so.ea.EA`).
     """

moptipy/algorithms/so/fitnesses/rank_and_iteration.py

@@ -14,6 +14,13 @@
    Estimation, Simulation, and Control - Wiley-Interscience Series in Discrete
    Mathematics and Optimization, volume 6. 2003. Chichester, West Sussex, UK:
    Wiley Interscience. ISBN: 0-471-33052-3. http://www.jhuapl.edu/ISSO/.
+3. Frank Hoffmeister and Thomas Bäck. Genetic Algorithms and Evolution
+   Strategies: Similarities and Differences. In Hans-Paul Schwefel and
+   Reinhard Männer, *Proceedings of the International Conference on Parallel
+   Problem Solving from Nature (PPSN I),* October 1-3, 1990, Dortmund,
+   Germany, volume 496 of Lecture Notes in Computer Science, pages 455-469,
+   Berlin/Heidelberg, Germany: Springer. ISBN: 978-3-540-54148-6.
+   https://doi.org/10.1007/BFb0029787.
 """
 from typing import Final, Union, Callable, List, cast, Optional
 
@@ -22,7 +29,7 @@
 from moptipy.algorithms.modules.selection import Selection, check_selection
 from moptipy.algorithms.modules.selections.random_without_replacement \
     import RandomWithoutReplacement
-from moptipy.algorithms.modules.selections.truncation import Truncation
+from moptipy.algorithms.modules.selections.best import Best
 from moptipy.algorithms.so.ea import EA, _float_0
 from moptipy.algorithms.so.fitness import check_fitness, Fitness, FRecord
 from moptipy.algorithms.so.fitnesses.rank_and_iteration import RankAndIteration
@@ -174,10 +181,10 @@ def __init__(self, op0: Op0,
         if fitness.__class__ is not RankAndIteration:
             name = f"{name}{PART_SEPARATOR}{fitness}"
         if survival is None:
-            survival = Truncation()
+            survival = Best()
         if mating is None:
             mating = RandomWithoutReplacement()
-        if (survival.__class__ is not Truncation) \
+        if (survival.__class__ is not Best) \
                 or (mating.__class__ is not RandomWithoutReplacement):
             name = f"{name}{PART_SEPARATOR}{survival}{PART_SEPARATOR}{mating}"
 

moptipy/algorithms/so/full_ea.py

@@ -24,9 +24,7 @@ def __init__(self, x, z):
         self.z: Final[int] = z
 
 
-def validate_fitness(fitness: Fitness,
-                     objective: Objective,
-                     space: Space,
+def validate_fitness(fitness: Fitness, objective: Objective, space: Space,
                      op0: Op0) -> None:
     """
     Validate a fitness assignment process on a given problem.