refactor names in genetic_algorithm.py

Author: mozman

examples/addons/optimize/bin_packing_forms.py

@@ -76,15 +76,17 @@ def feedback(optimizer: ga.GeneticOptimizer):
     evaluator = bp.SubSetEvaluator(packer)
     optimizer = ga.GeneticOptimizer(evaluator, max_generations=GENERATIONS)
     optimizer.name = "pack item subset"
-    optimizer.add_dna(ga.BitDNA.n_random(DNA_COUNT, len(packer.items)))
+    optimizer.crossover_rate = 0.9
+    optimizer.mutation_rate = 0.01
+    optimizer.add_candidates(ga.BitDNA.n_random(DNA_COUNT, len(packer.items)))
     print(
         f"\nGenetic algorithm search: {optimizer.name}\n"
-        f"max generations={optimizer.max_generations}, DNA count={optimizer.dna_count}"
+        f"max generations={optimizer.max_generations}, DNA count={optimizer.count}"
     )
     optimizer.execute(feedback, interval=3)
     print(
-        f"GeneticOptimizer: {optimizer.generation} generations x {optimizer.dna_count} "
-        f"DNA strands, best result:"
+        f"GeneticOptimizer: {optimizer.generation} generations x {optimizer.count} "
+        f"candidates, best result:"
     )
     evaluator = cast(bp.SubSetEvaluator, optimizer.evaluator)
     best_packer = evaluator.run_packer(optimizer.best_dna)

examples/addons/optimize/tsp.py

@@ -77,13 +77,6 @@ def evaluate(self, dna: ga.DNA) -> float:
         return -sum_dist([self.cities[i] for i in dna])
 
 
-class SAEvaluator(TSPEvaluator):
-    """Traveling Salesmen Problem"""
-
-    def evaluate(self, dna: ga.DNA) -> float:
-        return abs(super().evaluate(dna))
-
-
 def show_log(log: ga.Log, name: str):
     x = []
     y = []
@@ -143,11 +136,11 @@ def genetic_probing(data, seed):
     # preserve <elitism> overall best solutions in each generation
     optimizer.elitism = ELITISM
 
-    optimizer.add_dna(ga.UniqueIntDNA.n_random(300, length=len(data)))
+    optimizer.add_candidates(ga.UniqueIntDNA.n_random(300, length=len(data)))
     optimizer.execute(feedback, 2)
 
     print(
-        f"GeneticOptimizer: {optimizer.generation} generations x {optimizer.dna_count} "
+        f"GeneticOptimizer: {optimizer.generation} generations x {optimizer.count} "
         f"DNA strands, best result:"
     )
     evaluator = cast(TSPEvaluator, optimizer.evaluator)

profiling/binpacking.py

@@ -100,7 +100,7 @@ def make_subset_optimizer(
     evaluator = bp.SubSetEvaluator(packer)
     optimizer = ga.GeneticOptimizer(evaluator, max_generations=generations)
     optimizer.name = "pack item subset"
-    optimizer.add_dna(ga.BitDNA.n_random(dna_count, len(packer.items)))
+    optimizer.add_candidates(ga.BitDNA.n_random(dna_count, len(packer.items)))
     return optimizer
 
 
@@ -115,11 +115,11 @@ def feedback(optimizer: ga.GeneticOptimizer):
 
     print(
         f"\nGenetic algorithm search: {optimizer.name}\n"
-        f"max generations={optimizer.max_generations}, DNA count={optimizer.dna_count}"
+        f"max generations={optimizer.max_generations}, DNA count={optimizer.count}"
     )
     optimizer.execute(feedback, interval=3.0)
     print(
-        f"GeneticOptimizer: {optimizer.generation} generations x {optimizer.dna_count} "
+        f"GeneticOptimizer: {optimizer.generation} generations x {optimizer.count} "
         f"DNA strands, best result:"
     )
     evaluator = cast(bp.SubSetEvaluator, optimizer.evaluator)

src/ezdxf/addons/genetic_algorithm.py

@@ -14,6 +14,10 @@
 import random
 import time
 
+# example usage:
+# examples\addons\optimize\bin_packing_forms.py
+# examples\addons\optimize\tsp.py
+
 
 class DNA(abc.ABC):
     """Abstract DNA class."""
@@ -412,7 +416,7 @@ def pick(self, count: int) -> Iterable[DNA]:
         ...
 
     @abc.abstractmethod
-    def reset(self, strands: Iterable[DNA]):
+    def reset(self, candidates: Iterable[DNA]):
         ...
 
 
@@ -483,7 +487,22 @@ def purge(self):
 
 
 class GeneticOptimizer:
-    """Optimization Algorithm."""
+    """A genetic algorithm (GA) is a meta-heuristic inspired by the process of
+    natural selection. Genetic algorithms are commonly used to generate
+    high-quality solutions to optimization and search problems by relying on
+    biologically inspired operators such as mutation, crossover and selection.
+
+    Source: https://en.wikipedia.org/wiki/Genetic_algorithm
+
+    This implementation searches always for the maximum fitness, fitness
+    comparisons are always done by the "greater than" operator (">").
+    The algorithm supports negative values to search for the minimum fitness
+    (e.g. Travelling Salesmen Problem: -900 > -1000). Reset the start fitness
+    by the method :meth:`reset_fitness` accordingly::
+
+        optimizer.reset_fitness(-1e99)
+
+    """
 
     def __init__(
         self,
@@ -492,11 +511,11 @@ def __init__(
         max_fitness: float = 1.0,
     ):
         if max_generations < 1:
-            raise ValueError("max_generations < 1")
+            raise ValueError("requires max_generations > 0")
         # data:
         self.name = "GeneticOptimizer"
         self.log = Log()
-        self._dna_strands: List[DNA] = []
+        self.candidates: List[DNA] = []
 
         # core components:
         self.evaluator: Evaluator = evaluator
@@ -510,8 +529,11 @@ def __init__(
         self.max_runtime: float = 1e99
         self.max_stagnation = 100
         self.crossover_rate = 0.70
-        self.mutation_rate = 0.001
+        self.mutation_rate = 0.01
         self.elitism: int = 2
+        # percentage (0.1 = 10%) of DNA strands with least fitness to ignore in
+        # next generation
+        self.threshold: float = 0.0
 
         # state of last (current) generation:
         self.generation: int = 0
@@ -530,12 +552,12 @@ def is_executed(self) -> bool:
         return bool(self.generation)
 
     @property
-    def dna_count(self) -> int:
-        return len(self._dna_strands)
+    def count(self) -> int:
+        return len(self.candidates)
 
-    def add_dna(self, dna: Iterable[DNA]):
+    def add_candidates(self, dna: Iterable[DNA]):
         if not self.is_executed:
-            self._dna_strands.extend(dna)
+            self.candidates.extend(dna)
         else:
             raise TypeError("already executed")
 
@@ -546,7 +568,7 @@ def execute(
     ) -> None:
         if self.is_executed:
             raise TypeError("can only run once")
-        if not self._dna_strands:
+        if not self.candidates:
             print("no DNA defined!")
         t0 = time.perf_counter()
         self.start_time = t0
@@ -569,7 +591,7 @@ def execute(
     def measure_fitness(self) -> None:
         self.stagnation += 1
         fitness_sum: float = 0.0
-        for dna in self._dna_strands:
+        for dna in self.candidates:
             if dna.fitness is not None:
                 fitness_sum += dna.fitness
                 continue
@@ -584,7 +606,7 @@ def measure_fitness(self) -> None:
 
         self.hall_of_fame.purge()
         try:
-            avg_fitness = fitness_sum / len(self._dna_strands)
+            avg_fitness = fitness_sum / len(self.candidates)
         except ZeroDivisionError:
             avg_fitness = 0.0
         self.log.add(
@@ -595,22 +617,22 @@ def measure_fitness(self) -> None:
 
     def next_generation(self) -> None:
         selector = self.selection
-        selector.reset(self._dna_strands)
-        dna_strands: List[DNA] = []
-        count = len(self._dna_strands)
+        selector.reset(self.candidates)
+        candidates: List[DNA] = []
+        count = len(self.candidates)
 
         if self.elitism > 0:
-            dna_strands.extend(self.hall_of_fame.get(self.elitism))
+            candidates.extend(self.hall_of_fame.get(self.elitism))
 
-        while len(dna_strands) < count:
+        while len(candidates) < count:
             dna1, dna2 = selector.pick(2)
             dna1 = dna1.copy()
             dna2 = dna2.copy()
             self.recombine(dna1, dna2)
             self.mutate(dna1, dna2)
-            dna_strands.append(dna1)
-            dna_strands.append(dna2)
-        self._dna_strands = dna_strands
+            candidates.append(dna1)
+            candidates.append(dna2)
+        self.candidates = candidates
 
     def recombine(self, dna1: DNA, dna2: DNA):
         if random.random() < self.crossover_rate:
@@ -630,50 +652,50 @@ class RouletteSelection(Selection):
     """Selection by fitness values."""
 
     def __init__(self, negative_values=False):
-        self._strands: List[DNA] = []
+        self._candidates: List[DNA] = []
         self._weights: List[float] = []
         self._negative_values = bool(negative_values)
 
-    def reset(self, strands: Iterable[DNA]):
+    def reset(self, candidates: Iterable[DNA]):
         # dna.fitness is not None here!
-        self._strands = list(strands)
+        self._candidates = list(candidates)
         if self._negative_values:
             self._weights = list(
-                conv_negative_weights(dna.fitness for dna in self._strands)  # type: ignore
+                conv_negative_weights(dna.fitness for dna in self._candidates)  # type: ignore
             )
         else:
-            self._weights = [dna.fitness for dna in self._strands]  # type: ignore
+            self._weights = [dna.fitness for dna in self._candidates]  # type: ignore
 
     def pick(self, count: int) -> Iterable[DNA]:
-        return random.choices(self._strands, self._weights, k=count)
+        return random.choices(self._candidates, self._weights, k=count)
 
 
 class RankBasedSelection(RouletteSelection):
     """Selection by rank of fitness."""
 
-    def reset(self, strands: Iterable[DNA]):
+    def reset(self, candidates: Iterable[DNA]):
         # dna.fitness is not None here!
-        self._strands = list(strands)
-        self._strands.sort(key=dna_fitness)  # type: ignore
+        self._candidates = list(candidates)
+        self._candidates.sort(key=dna_fitness)  # type: ignore
         # weight of best_fitness == len(strands)
         # and decreases until 1 for the least fitness
-        self._weights = list(range(1, len(self._strands) + 1))
+        self._weights = list(range(1, len(self._candidates) + 1))
 
 
 class TournamentSelection(Selection):
     """Selection by choosing the best of a certain count of candidates."""
 
     def __init__(self, candidates: int):
-        self._strands: List[DNA] = []
+        self._candidates: List[DNA] = []
         self.candidates = candidates
 
-    def reset(self, strands: Iterable[DNA]):
-        self._strands = list(strands)
+    def reset(self, candidates: Iterable[DNA]):
+        self._candidates = list(candidates)
 
     def pick(self, count: int) -> Iterable[DNA]:
         for _ in range(count):
             values = [
-                random.choice(self._strands) for _ in range(self.candidates)
+                random.choice(self._candidates) for _ in range(self.candidates)
             ]
             values.sort(key=dna_fitness)  # type: ignore
             yield values[-1]

tests/test_08_addons/test_817_genetic_algorithm.py

@@ -80,7 +80,7 @@ def test_subscription_setter(self):
         assert dna[-4:] == [True, False, False, False]
 
 
-class TestUniquIntDNA:
+class TestUniqueIntDNA:
     def test_init_value(self):
         dna = ga.UniqueIntDNA(10)
         assert dna.is_valid is True
@@ -178,41 +178,41 @@ def test_new_random_dna(self):
 
 class TestHallOfFame:
     @pytest.fixture
-    def strands(self):
+    def candidates(self):
         s = []
         for fitness in range(1, 10):
             dna = ga.BitDNA.random(5)
             dna.fitness = 0.1 * fitness
             s.append(dna)
         return s
 
-    def test_build(self, strands):
+    def test_build(self, candidates):
         hof = ga.HallOfFame(3)
-        for dna in strands:
+        for dna in candidates:
             hof.add(dna)
         assert [dna.fitness for dna in hof] == pytest.approx([0.9, 0.8, 0.7])
 
-    def test_get_n_best(self, strands):
+    def test_get_n_best(self, candidates):
         hof = ga.HallOfFame(3)
-        for dna in strands:
+        for dna in candidates:
             hof.add(dna)
         result = hof.get(2)
         assert result[0].fitness == pytest.approx(0.9)
         assert result[1].fitness == pytest.approx(0.8)
 
-    def test_get_n_best_negative_values(self, strands):
-        for dna in strands:
+    def test_get_n_best_negative_values(self, candidates):
+        for dna in candidates:
             dna.fitness = -dna.fitness
         hof = ga.HallOfFame(3)
-        for dna in strands:
+        for dna in candidates:
             hof.add(dna)
         result = hof.get(2)
         assert result[0].fitness == pytest.approx(-0.1)
         assert result[1].fitness == pytest.approx(-0.2)
 
-    def test_purge(self, strands):
+    def test_purge(self, candidates):
         hof = ga.HallOfFame(3)
-        for dna in strands:
+        for dna in candidates:
             hof.add(dna)
         hof.purge()
         assert len(hof._unique_entries) == 3
@@ -235,11 +235,11 @@ def test_scramble_mutate():
 
 
 def test_tournament_selection():
-    strands = [ga.UniqueIntDNA(10) for _ in range(10)]
-    for index, dna in enumerate(strands):
+    candidates = [ga.UniqueIntDNA(10) for _ in range(10)]
+    for index, dna in enumerate(candidates):
         dna.fitness = index
     selection = ga.TournamentSelection(2)
-    selection.reset(strands)
+    selection.reset(candidates)
 
     result = list(selection.pick(2))
     assert len(result) == 2
@@ -360,7 +360,7 @@ def test_execution(self, packer):
         packer.add_bin(*MEDIUM_BOX)
         evaluator = DummyEvaluator(packer)
         optimizer = ga.GeneticOptimizer(evaluator, 10)
-        optimizer.add_dna(ga.BitDNA.n_random(20, len(packer.items)))
+        optimizer.add_candidates(ga.BitDNA.n_random(20, len(packer.items)))
         optimizer.execute()
         assert optimizer.generation == 10
         assert optimizer.best_fitness > 0.1