Removed explicit support for statistics gathering and checkpointing from Population, as this can be implemented via reporters.

Modified genome distance computation to consider "excess" genes to be the same as disjoint.
Refactoring of gene-specific distance computation into gene classes.
Renamed the "fully_connected" connection option to "full".
Fix minor annoyances in __str__ method formatting.
Import commonly used items into the package-level namespace.
Update create_feed_forward_phenotype to work with current genome implementation.
Updated XOR example to work with current implementation.

Author: CodeReclaimers

examples/xor/xor2.py

@@ -3,23 +3,55 @@
 """
 
 from __future__ import print_function
-
+import os
 import neat
+import visualize
 
-# Inputs and expected outputs.
+# 2-input XOR inputs and expected outputs.
 xor_inputs = [(0.0, 0.0), (0.0, 1.0), (1.0, 0.0), (1.0, 1.0)]
 xor_outputs = [   (0.0,),     (1.0,),     (1.0,),     (0.0,)]
 
-# Create a SequentialStatic instance and use it to evolve a network.
-n = neat.SequentialStatic(xor_inputs, xor_outputs)
-winner = n.evolve(300)
 
-# Display the winning genome.
-print('\nBest genome:\n{!s}'.format(winner))
+def eval_genomes(genomes, config):
+    for genome_id, genome in genomes:
+        genome.fitness = 1.0
+        net = neat.nn.create_feed_forward_phenotype(genome, config)
+        for xi, xo in zip(xor_inputs, xor_outputs):
+            output = net.activate(xi)
+            genome.fitness -= (output[0] - xo[0]) ** 2
+
+
+def run(config_file):
+    # Load configuration.
+    config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                         neat.DefaultStagnation, config_file)
+
+    # Create the population, which is the top-level object for a NEAT run.
+    p = neat.Population(config)
+
+    # Add a stdout reporter to show progress in the terminal.
+    p.add_reporter(neat.StdOutReporter())
+
+    # Run for up to 300 generations.
+    winner = p.run(eval_genomes, 300)
+
+    # Display the winning genome.
+    print('\nBest genome:\n{!s}'.format(winner))
+
+    # Show output of the most fit genome against training data.
+    print('\nOutput:')
+    winner_net = neat.nn.create_feed_forward_phenotype(winner, config)
+    for xi, xo in zip(xor_inputs, xor_outputs):
+        output = winner_net.activate(xi)
+        print("input {!r}, expected output {!r}, got {!r}".format(xi, xo, output))
 
-# Show output of the most fit genome against training data.
-print('\nOutput:')
-for inputs, expected, outputs in n.evaluate(winner):
-    print("input {!r}, expected output {!r}, got {!r}".format(inputs, expected, outputs[0]))
+    node_names = {-1:'A', -2: 'B', 0:'A XOR B'}
+    visualize.draw_net(config, winner, True, node_names = node_names)
 
-print("Total number of evaluations: {}".format(n.total_evaluations))
+if __name__ == '__main__':
+    # Determine path to configuration file. This path manipulation is
+    # here so that the script will run successfully regardless of the
+    # current working directory.
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, 'xor2_config')
+    run(config_path)

examples/xor/xor2_config

@@ -1,55 +1,69 @@
 #--- parameters for the XOR-2 experiment ---#
 
-# The `Types` section specifies which classes should be used for various
-# tasks in the NEAT algorithm.  If you use a non-default class here, you
-# must register it with your Config instance before loading the config file.
-[Types]
-stagnation_type      = DefaultStagnation
-reproduction_type    = DefaultReproduction
-genome_type          = DefaultGenome
-
-[phenotype]
-input_nodes          = 2
-hidden_nodes         = 0
-output_nodes         = 1
-initial_connection   = unconnected
-max_weight           = 30
-min_weight           = -30
-activation_functions = sigmoid
-aggregation_functions = sum
-weight_stdev         = 1.0
+# The `NEAT` section specifies parameters particular to the NEAT algorithm
+# or the experiment itself.  This is the only required section.
+[NEAT]
+pop_size              = 150
+max_fitness_threshold = 0.95
+reset_on_extinction   = False
 
 [DefaultGenome]
-
-[genetic]
-pop_size                = 150
-max_fitness_threshold   = 0.95
-prob_add_conn           = 0.988
-prob_add_node           = 0.085
-prob_delete_conn        = 0.146
-prob_delete_node        = 0.0352
-prob_mutate_bias        = 0.0509
-bias_mutation_power     = 2.093
-prob_mutate_response    = 0.1
-response_mutation_power = 0.1
-prob_mutate_weight      = 0.460
-prob_replace_weight     = 0.0245
-weight_mutation_power   = 0.825
-prob_mutate_activation  = 0.0
-prob_mutate_aggregation = 0.0
-prob_toggle_link        = 0.0138
-reset_on_extinction     = 1
-
-[genotype compatibility]
+num_inputs              = 2
+num_hidden              = 0
+num_outputs             = 1
+initial_connection      = full
+feed_forward            = 0
+# genome compatibility options
 compatibility_threshold = 3.0
-excess_coefficient      = 1.0
 disjoint_coefficient    = 1.0
-weight_coefficient      = 0.4
+weight_coefficient      = 0.5
+# connection add/remove rates
+conn_add_prob           = 0.5
+conn_delete_prob        = 0.25
+# node add/remove rates
+node_add_prob           = 0.1
+node_delete_prob        = 0.05
+# node activation options
+activation_default      = sigmoid
+activation_options      = sigmoid
+activation_mutate_rate  = 0.0
+# node aggregation options
+aggregation_default     = sum
+aggregation_options     = sum
+aggregation_mutate_rate = 0.0
+# node bias options
+bias_init_mean          = 0.0
+bias_init_stdev         = 1.0
+bias_replace_rate       = 0.1
+bias_mutate_rate        = 0.7
+bias_mutate_power       = 0.5
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+# node response options
+response_init_mean      = 5.0
+response_init_stdev     = 0.1
+response_replace_rate   = 0.1
+response_mutate_rate    = 0.2
+response_mutate_power   = 0.1
+response_max_value      = 30.0
+response_min_value      = -30.0
+# connection weight options
+weight_max_value        = 30
+weight_min_value        = -30
+weight_init_mean        = 0.0
+weight_init_stdev       = 1.0
+weight_mutate_rate      = 0.8
+weight_replace_rate     = 0.1
+weight_mutate_power     = 0.5
+# connection enable options
+enabled_default         = True
+enabled_mutate_rate     = 0.01
 
 [DefaultStagnation]
-species_fitness_func = mean
-max_stagnation       = 15
+species_fitness = median
+max_stagnation  = 10
 
 [DefaultReproduction]
-elitism              = 1
-survival_threshold   = 0.2
+elitism            = 2
+survival_threshold = 0.2
+

neat/__init__.py

@@ -1,2 +1,15 @@
 from neat.sequential_static import SequentialStatic
 
+import neat.nn as nn
+import neat.iznn as iznn
+
+from neat.config import Config
+from neat.population import Population
+from neat.genome import DefaultGenome
+from neat.reproduction import DefaultReproduction
+from neat.stagnation import DefaultStagnation
+from neat.reporting import StdOutReporter
+from neat.statistics import StatisticsReporter
+
+
+

neat/config.py

@@ -71,10 +71,7 @@ class Config(object):
 
     __params = [ConfigParameter('pop_size', int),
                 ConfigParameter('max_fitness_threshold', float),
-                ConfigParameter('reset_on_extinction', bool),
-                ConfigParameter('collect_statistics', bool),
-                ConfigParameter('report', bool),
-                ConfigParameter('save_best', bool)]
+                ConfigParameter('reset_on_extinction', bool)]
 
     def __init__(self, genome_type, reproduction_type, stagnation_type, filename):
         # Check that the provided types have the required methods.
@@ -113,12 +110,6 @@ def __init__(self, genome_type, reproduction_type, stagnation_type, filename):
         reproduction_dict = dict(parameters.items(reproduction_type.__name__))
         self.reproduction_config = reproduction_type.parse_config(reproduction_dict)
 
-        # Time in minutes between saving checkpoints, None for no timed checkpoints.
-        self.checkpoint_time_interval = None
-
-        # Time in generations between saving checkpoints, None for no generational checkpoints.
-        self.checkpoint_gen_interval = None
-
     def save(self, filename):
         with open(filename, 'w') as f:
             f.write('# The `NEAT` section specifies parameters particular to the NEAT algorithm\n')

neat/genes.py

@@ -4,15 +4,14 @@
 # TODO: There is probably a lot of room for simplification of these classes using metaprogramming.
 # TODO: Evaluate using __slots__ for performance/memory usage improvement.
 
-
 class BaseGene(object):
     def __init__(self, key):
         self.key = key
 
     def __str__(self):
         attrib = ['key'] + [a.name for a in self.__gene_attributes__]
         attrib = ['{0}={1}'.format(a, getattr(self, a)) for a in attrib]
-        return '{0}({1})'.format(__class__.__name__, "".join(attrib))
+        return '{0}({1})'.format(__class__.__name__, ", ".join(attrib))
 
     def __lt__(self, other):
         return self.key < other.key
@@ -62,6 +61,7 @@ def crossover(self, gene2):
 
 # TODO: Create some kind of aggregated config object that can replace
 # most of DefaultGeneConfig and genome.DefaultGenomeConfig?
+# TODO: Should these be in the nn module?  iznn and ctrnn can have additional attributes.
 
 class DefaultGeneConfig(object):
     def __init__(self, attribs, params):
@@ -88,8 +88,11 @@ class DefaultNodeGene(BaseGene):
     def parse_config(cls, config, param_dict):
         return DefaultGeneConfig(cls.__gene_attributes__, param_dict)
 
-    def distance(self, other):
-        raise NotImplementedError()
+    def distance(self, other, config):
+        d = abs(self.bias - other.bias) + abs(self.response - other.response)
+        if self.activation != other.activation:
+            d += 1.0
+        return d * config.weight_coefficient
 
 
 # TODO: Do an ablation study to determine whether the enabled setting is
@@ -103,5 +106,9 @@ class DefaultConnectionGene(BaseGene):
     def parse_config(cls, config, param_dict):
         return DefaultGeneConfig(cls.__gene_attributes__, param_dict)
 
-    def distance(self, other):
-        raise NotImplementedError()
+    def distance(self, other, config):
+        d = abs(self.weight - other.weight)
+        if self.enabled != other.enabled:
+            d += 1.0
+        return d * config.weight_coefficient
+