Break out speciation into a user-specifiable class.

StdOutReporter now shows average generation time for last 10 generations.
Updated XOR example.
Minor fixes/cleanup.
Added TODO items.

Author: CodeReclaimers

examples/xor/config-feedforward

@@ -1,7 +1,5 @@
 #--- parameters for the XOR-2 experiment ---#
 
-# The `NEAT` section specifies parameters particular to the NEAT algorithm
-# or the experiment itself.  This is the only required section.
 [NEAT]
 max_fitness_threshold = 0.9
 pop_size              = 150
@@ -29,7 +27,6 @@ bias_replace_rate       = 0.1
 
 # genome compatibility options
 compatibility_disjoint_coefficient = 1.0
-compatibility_threshold            = 3.0
 compatibility_weight_coefficient   = 0.5
 
 # connection add/remove rates
@@ -70,6 +67,9 @@ weight_mutate_power     = 0.5
 weight_mutate_rate      = 0.8
 weight_replace_rate     = 0.1
 
+[DefaultSpeciesSet]
+compatibility_threshold = 3.0
+
 [DefaultStagnation]
 species_fitness_func = max
 max_stagnation       = 20

examples/xor/evolve-feedforward-parallel.py

@@ -64,7 +64,7 @@ def run(config_file):
     p.add_reporter(stats)
 
     # Run for up to 300 generations.
-    pe = neat.parallel.ParallelEvaluator(4, eval_genome)
+    pe = neat.ParallelEvaluator(4, eval_genome)
     winner = p.run(pe.evaluate, 300)
 
     # Display the winning genome.

examples/xor/evolve-feedforward.py

@@ -24,7 +24,8 @@ def eval_genomes(genomes, config):
 def run(config_file):
     # Load configuration.
     config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
-                         neat.DefaultStagnation, config_file)
+                         neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                         config_file)
 
     # Create the population, which is the top-level object for a NEAT run.
     p = neat.Population(config)

neat/__init__.py

@@ -9,6 +9,7 @@
 from neat.reproduction import DefaultReproduction
 from neat.stagnation import DefaultStagnation
 from neat.reporting import StdOutReporter
+from neat.species import DefaultSpeciesSet
 from neat.statistics import StatisticsReporter
 from neat.parallel import ParallelEvaluator
 

neat/config.py

@@ -73,15 +73,17 @@ class Config(object):
                 ConfigParameter('max_fitness_threshold', float),
                 ConfigParameter('reset_on_extinction', bool)]
 
-    def __init__(self, genome_type, reproduction_type, stagnation_type, filename):
+    def __init__(self, genome_type, reproduction_type, species_set_type, stagnation_type, filename):
         # Check that the provided types have the required methods.
         assert hasattr(genome_type, 'parse_config')
         assert hasattr(reproduction_type, 'parse_config')
+        assert hasattr(species_set_type, 'parse_config')
         assert hasattr(stagnation_type, 'parse_config')
 
         self.genome_type = genome_type
-        self.stagnation_type = stagnation_type
         self.reproduction_type = reproduction_type
+        self.species_set_type = species_set_type
+        self.stagnation_type = stagnation_type
 
         if not os.path.isfile(filename):
             raise Exception('No such config file: ' + os.path.abspath(filename))
@@ -104,6 +106,9 @@ def __init__(self, genome_type, reproduction_type, stagnation_type, filename):
         genome_dict = dict(parameters.items(genome_type.__name__))
         self.genome_config = genome_type.parse_config(genome_dict)
 
+        species_set_dict = dict(parameters.items(species_set_type.__name__))
+        self.species_set_config = species_set_type.parse_config(species_set_dict)
+
         stagnation_dict = dict(parameters.items(stagnation_type.__name__))
         self.stagnation_config = stagnation_type.parse_config(stagnation_dict)
 

neat/genome.py

@@ -3,7 +3,7 @@
 
 from neat.config import ConfigParameter, write_pretty_params
 from neat.genes import DefaultConnectionGene, DefaultNodeGene
-from neat.six_util import iteritems, itervalues, iterkeys
+from neat.six_util import iteritems, iterkeys
 
 from neat.activations import ActivationFunctionSet
 from neat.graphs import creates_cycle
@@ -20,7 +20,6 @@ class DefaultGenomeConfig(object):
                 ConfigParameter('num_outputs', int),
                 ConfigParameter('num_hidden', int),
                 ConfigParameter('feed_forward', bool),
-                ConfigParameter('compatibility_threshold', float),
                 ConfigParameter('compatibility_disjoint_coefficient', float),
                 ConfigParameter('compatibility_weight_coefficient', float),
                 ConfigParameter('conn_add_prob', float),
@@ -67,18 +66,17 @@ def add_activation(self, name, func):
         self.activation_defs.add(name, func)
 
     def save(self, f):
-        # TODO: Handle the initial_connection setting.
-        # f.write('initial_connection      = {0}\n'.format(self.initial_connection))
+        f.write('initial_connection      = {0}\n'.format(self.initial_connection))
         # Verify that initial connection type is valid.
-        # self.initial_connection = params.get('', 'unconnected')
-        # if 'partial' in self.initial_connection:
-        #     c, p = self.initial_connection.split()
-        #     self.initial_connection = c
-        #     self.connection_fraction = float(p)
-        #     if not (0 <= self.connection_fraction <= 1):
-        #         raise Exception("'partial' connection value must be between 0.0 and 1.0, inclusive.")
-        #
-        # assert self.initial_connection in self.allowed_connectivity
+        if 'partial' in self.initial_connection:
+            c, p = self.initial_connection.split()
+            self.initial_connection = c
+            self.connection_fraction = float(p)
+            if not (0 <= self.connection_fraction <= 1):
+                raise Exception("'partial' connection value must be between 0.0 and 1.0, inclusive.")
+
+        assert self.initial_connection in self.allowed_connectivity
+
         write_pretty_params(f, self, self.__params)
 
 
@@ -322,9 +320,7 @@ def distance(self, other, config):
             connection_distance = (connection_distance + config.compatibility_disjoint_coefficient * disjoint_connections) / max_conn
 
         distance = node_distance + connection_distance
-        compatible = distance < config.compatibility_threshold
-
-        return distance, compatible
+        return distance
 
     def size(self):
         '''Returns genome 'complexity', taken to be (number of nodes, number of enabled connections)'''
@@ -392,7 +388,7 @@ def create_unconnected(cls, config, key):
 
     def connect_fs_neat(self, config):
         """ Randomly connect one input to all hidden and output nodes (FS-NEAT). """
-        input_id = choice(self.inputs.keys())
+        input_id = choice(config.input_keys)
         for output_id in list(self.hidden.keys()) + list(self.outputs.keys()):
             connection = self.create_connection(config, input_id, output_id)
             self.connections[connection.key] = connection

neat/graphs.py

@@ -10,7 +10,7 @@ def creates_cycle(connections, test):
     if i == o:
         return True
 
-    visited = set([o])
+    visited = {o}
     while True:
         num_added = 0
         for a, b in connections:

neat/population.py

@@ -1,7 +1,6 @@
 from __future__ import print_function
 
 from neat.reporting import ReporterSet
-from neat.species import SpeciesSet
 from neat.six_util import iteritems, itervalues
 
 
@@ -21,7 +20,7 @@ def __init__(self, config, initial_state=None):
         if initial_state is None:
             # Create a population from scratch, then partition into species.
             self.population = self.reproduction.create_new(config.genome_type, config.genome_config, config.pop_size)
-            self.species = SpeciesSet(config)
+            self.species = config.species_set_type(config)
             self.species.speciate(config, self.population)
             self.generation = -1
         else:

neat/reporting.py

@@ -5,6 +5,7 @@
 from neat.math_util import mean, stdev
 from neat.six_util import itervalues
 
+# TODO: Add a curses-based reporter.
 
 class ReporterSet(object):
     def __init__(self):
@@ -87,14 +88,22 @@ class StdOutReporter(BaseReporter):
     def __init__(self):
         self.generation = None
         self.generation_start_time = None
+        self.generation_times = []
 
     def start_generation(self, generation):
         self.generation = generation
         print('\n ****** Running generation {0} ****** \n'.format(generation))
         self.generation_start_time = time.time()
 
     def end_generation(self):
-        print("Generation time: {0:.3f} sec".format(time.time() - self.generation_start_time))
+        elapsed = time.time() - self.generation_start_time
+        self.generation_times.append(elapsed)
+        self.generation_times = self.generation_times[-10:]
+        average = sum(self.generation_times) / len(self.generation_times)
+        if len(self.generation_times) > 1:
+            print("Generation time: {0:.3f} sec ({1:.3f} average)".format(elapsed, average))
+        else:
+            print("Generation time: {0:.3f} sec".format(elapsed))
 
     def loading_checkpoint(self, filename):
         print('Resuming from a previous point: ' + filename)

neat/reproduction.py

@@ -17,6 +17,7 @@ class DefaultReproduction(object):
     scheme: explicit fitness sharing with fixed-time species stagnation.
     """
 
+    # TODO: Create a separate configuration class instead of using a dict (for consistency with other types).
     @classmethod
     def parse_config(cls, param_dict):
         config = {'elitism': 1,

neat/species.py

@@ -34,16 +34,26 @@ def median_fitness(self):
         return fitnesses[len(fitnesses) // 2]
 
 
-class SpeciesSet(object):
-    """
-    Encapsulates the speciation scheme.
-    """
+class DefaultSpeciesSet(object):
+    """ Encapsulates the default speciation scheme. """
 
     def __init__(self, config):
         self.indexer = Indexer(1)
         self.species = {}
         self.to_species = {}
 
+    # TODO: Create a separate configuration class instead of using a dict (for consistency with other types).
+    @classmethod
+    def parse_config(cls, param_dict):
+        config = {'compatibility_threshold': float(param_dict['compatibility_threshold'])}
+
+        return config
+
+    @classmethod
+    def write_config(cls, f, param_dict):
+        compatibility_threshold = param_dict['compatibility_threshold']
+        f.write('compatibility_threshold = {}\n'.format(compatibility_threshold))
+
     def speciate(self, config, population):
         """
         Place genomes into species by genetic similarity.
@@ -56,6 +66,8 @@ def speciate(self, config, population):
         """
         assert type(population) is dict
 
+        compatibility_threshold = config.species_set_config['compatibility_threshold']
+
         # Reset all species member lists.
         for s in itervalues(self.species):
             s.members.clear()
@@ -69,7 +81,9 @@ def speciate(self, config, population):
             closest_species_id = None
             for sid, s in iteritems(self.species):
                 rep = s.representative
-                distance, compatible = individual.distance(rep, config.genome_config)
+                distance = individual.distance(rep, config.genome_config)
+                compatible = distance < compatibility_threshold
+
                 if compatible and distance < min_distance:
                     closest_species = s
                     closest_species_id = sid