Enforce population size to be exactly the number of genomes specified in config.

Author: CodeReclaimers

CHANGELOG.md

@@ -42,6 +42,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Full documentation in example README with usage tips
 
 ### Fixed
+- **Population Size Drift**: Fixed small mismatches between actual population size and configured `pop_size`
+  - `DefaultReproduction.reproduce()` now strictly enforces `len(population) == config.pop_size` for every non-extinction generation
+  - New `_adjust_spawn_exact` helper adjusts per-species spawn counts after `compute_spawn()` to correct rounding/clamping drift
+  - When adding individuals, extra genomes are allocated to smaller species first; when removing, genomes are taken from larger species first
+  - Per-species minima (`min_species_size` and elitism) are always respected; invalid configurations (e.g., `pop_size < num_species * min_species_size`) raise a clear error
+  - New tests in `tests/test_reproduction.py` ensure `DefaultReproduction.reproduce()` preserves exact population size over multiple generations
 - **Orphaned Nodes Bug**: Fixed silent failure when nodes have no incoming connections after deletion mutations
   - `feed_forward_layers()` now correctly handles orphaned nodes (nodes with no incoming connections)
   - Orphaned nodes are treated as "bias neurons" that output `activation(bias)` independent of inputs

neat/reproduction.py

@@ -91,6 +91,69 @@ def compute_spawn(adjusted_fitness, previous_sizes, pop_size, min_species_size):
 
         return spawn_amounts
 
+    def _adjust_spawn_exact(self, spawn_amounts, pop_size, min_species_size):
+        """Adjust per-species spawn counts so that their sum matches pop_size exactly.
+
+        This adjustment preserves the per-species minimum (min_species_size) and biases
+        changes as follows:
+        - When adding individuals (total < pop_size), smaller species are incremented first.
+        - When removing individuals (total > pop_size), larger species are decremented first.
+        """
+        total_spawn = sum(spawn_amounts)
+        if total_spawn == pop_size:
+            return spawn_amounts
+
+        num_species = len(spawn_amounts)
+        min_total = num_species * min_species_size
+        if min_total > pop_size:
+            raise RuntimeError(
+                "Configuration conflict: population size {0} is less than "
+                "num_species * min_species_size {1} ({2} * {3}). Cannot satisfy per-species minima.".format(
+                    pop_size, min_total, num_species, min_species_size
+                )
+            )
+
+        diff = pop_size - total_spawn
+        indexed = list(enumerate(spawn_amounts))
+
+        if diff > 0:
+            # Too few genomes overall: give extras to smaller species first.
+            indexed.sort(key=lambda x: x[1])  # ascending by current spawn size
+            i = 0
+            while diff > 0 and indexed:
+                idx, val = indexed[i]
+                val += 1
+                spawn_amounts[idx] = val
+                indexed[i] = (idx, val)
+                diff -= 1
+                i = (i + 1) % len(indexed)
+        else:
+            # Too many genomes overall: remove from larger species first.
+            remaining = -diff
+            indexed.sort(key=lambda x: x[1], reverse=True)  # descending by current spawn size
+            i = 0
+            # We know a solution should exist whenever min_total <= pop_size, but
+            # guard against pathological rounding behaviour with a safety break.
+            while remaining > 0 and indexed:
+                idx, val = indexed[i]
+                if val > min_species_size:
+                    val -= 1
+                    spawn_amounts[idx] = val
+                    indexed[i] = (idx, val)
+                    remaining -= 1
+                i = (i + 1) % len(indexed)
+                if i == 0 and remaining > 0:
+                    # Could not adjust further without violating the per-species minimum.
+                    break
+
+        if sum(spawn_amounts) != pop_size:
+            raise RuntimeError(
+                "Internal error adjusting spawn counts: could not match pop_size={0} "
+                "with min_species_size={1}".format(pop_size, min_species_size)
+            )
+
+        return spawn_amounts
+
     def reproduce(self, config, species, pop_size, generation):
         """
         Handles creation of genomes, either from scratch or by sexual or
@@ -156,6 +219,9 @@ def reproduce(self, config, species, pop_size, generation):
         min_species_size = max(min_species_size, self.reproduction_config.elitism)
         spawn_amounts = self.compute_spawn(adjusted_fitnesses, previous_sizes,
                                            pop_size, min_species_size)
+        # Adjust spawn counts so that the total exactly matches the requested
+        # population size while respecting the per-species minimum.
+        spawn_amounts = self._adjust_spawn_exact(spawn_amounts, pop_size, min_species_size)
 
         new_population = {}
         species.species = {}

tests/test_reproduction.py

@@ -1,5 +1,9 @@
+import os
+import random
 import unittest
 
+import neat
+from neat.reporting import ReporterSet
 from neat.reproduction import DefaultReproduction
 
 
@@ -53,5 +57,45 @@ def test_spawn_adjust3(self):
         self.assertEqual(spawn, [20, 20])
 
 
+class TestReproducePopulationSize(unittest.TestCase):
+    def test_reproduce_respects_pop_size(self):
+        """DefaultReproduction.reproduce must always create exactly pop_size genomes."""
+        # Load configuration.
+        local_dir = os.path.dirname(__file__)
+        config_path = os.path.join(local_dir, 'test_configuration')
+        config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                             neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                             config_path)
+
+        pop_size = config.pop_size
+
+        # Set up the objects similarly to Population.__init__.
+        reporters = ReporterSet()
+        stagnation = config.stagnation_type(config.stagnation_config, reporters)
+        reproduction = config.reproduction_type(config.reproduction_config,
+                                                reporters, stagnation)
+        species_set = config.species_set_type(config.species_set_config, reporters)
+
+        # Create an initial population and speciate it.
+        population = reproduction.create_new(config.genome_type,
+                                             config.genome_config,
+                                             pop_size)
+        generation = 0
+        species_set.speciate(config, population, generation)
+
+        # Run several generations and ensure the population size is invariant.
+        random.seed(123)
+        for generation in range(5):
+            # Assign some non-degenerate fitness values.
+            for genome in population.values():
+                genome.fitness = random.random()
+
+            population = reproduction.reproduce(config, species_set, pop_size, generation)
+            self.assertEqual(len(population), pop_size)
+
+            # Prepare species for the next generation.
+            species_set.speciate(config, population, generation + 1)
+
+
 if __name__ == '__main__':
     unittest.main()