Another high-level refactoring pass.

Created the SequentialStatic wrapper to handle the "evolve a feed-forward network for tabular data" case boilerplate code.
ActivationFunctionSet now auto-adds the full set of activation functions in the initializer.
Config now sets default member values in the initializer, and the load() method must now explicitly be called.
Replaced the input, hidden and output node gene sets with a single node gene collection; adjusted network conventions to support this.
Pass config object around as necessary to support current refactoring.
Added refactoring reminder comments.
Expanded feed-forward network tests.

Author: CodeReclaimers

examples/xor/xor2.py

@@ -1,77 +1,25 @@
-""" 2-input XOR example """
-from __future__ import print_function
-
-import os
-
-from neat import nn, population, statistics
-
-
-# Network inputs and expected outputs.
-xor_inputs = [[0, 0], [0, 1], [1, 0], [1, 1]]
-xor_outputs = [0, 1, 1, 0]
-
-def ideal_demo():
-    import neat
-
-    # default Config
-    # default to parallel processing using auto-detected # hardware cores
-    n = neat.Sequential(xor_inputs, xor_outputs)
-
-    n.evolve(300)
-
-    n.save_statistics(".")
-
-    print('Number of evaluations: {0}'.format(n.total_evaluations))
-
-    # Show output of the most fit genome against training data.
-    winner = n.best_genome()
-    print('\nBest genome:\n{!s}'.format(winner))
-    print('\nOutput:')
-    winner_output = n.evaluate(winner, xor_inputs)
-    for inputs, expected, outputs in zip(xor_inputs, xor_outputs, winner_output):
-        print("input {!r}, expected output {0:1.5f} got {1:1.5f}".format(inputs, expected, outputs[0]))
+"""
+2-input XOR example -- this is most likely the simplest possible example.
+"""
 
+from __future__ import print_function
 
+import neat
 
-total_evaluations = 0
-
-def eval_fitness(genomes):
-    global total_evaluations
-    total_evaluations += len(genomes)
-
-    for gid, g in genomes:
-
-        net = nn.create_feed_forward_phenotype(g)
-
-        sum_square_error = 0.0
-        for inputs, expected in zip(xor_inputs, xor_outputs):
-            # Serial activation propagates the inputs through the entire network.
-            output = net.serial_activate(inputs)
-            sum_square_error += (output[0] - expected) ** 2
-
-        # When the output matches expected for all inputs, fitness will reach
-        # its maximum value of 1.0.
-        g.fitness = 1 - sum_square_error
-
-
-local_dir = os.path.dirname(__file__)
-config_path = os.path.join(local_dir, 'xor2_config')
-pop = population.Population(config_path)
-pop.run(eval_fitness, 300)
+# 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,)]
 
-# Log statistics.
-statistics.save_stats(pop.statistics)
-statistics.save_species_count(pop.statistics)
-statistics.save_species_fitness(pop.statistics)
+# Create a SequentialStatic instance and use it to evolve a network.
+n = neat.SequentialStatic(xor_inputs, xor_outputs)
+winner = n.evolve(300)
 
-print('Number of evaluations: {0}'.format(total_evaluations))
+# Display the winning genome.
+print('\nBest genome:\n{!s}'.format(winner))
 
 # Show output of the most fit genome against training data.
-winner = pop.statistics.best_genome()
-print('\nBest genome:\n{!s}'.format(winner))
 print('\nOutput:')
-winner_net = nn.create_feed_forward_phenotype(winner)
-for inputs, expected in zip(xor_inputs, xor_outputs):
-    output = winner_net.serial_activate(inputs)
-    print("expected {0:1.5f} got {1:1.5f}".format(expected, output[0]))
+for inputs, expected, outputs in n.evaluate(winner):
+    print("input {!r}, expected output {!r}, got {!r}".format(inputs, expected, outputs[0]))
 
+print("Total number of evaluations: {}".format(n.total_evaluations))

examples/xor/xor2_config

@@ -19,7 +19,7 @@ activation_functions = sigmoid
 aggregation_functions = sum
 weight_stdev         = 1.0
 
-[FFGenome]
+[DefaultGenome]
 
 [genetic]
 pop_size                = 150

neat/__init__.py

@@ -1,19 +1,2 @@
-from neat import activations
+from neat.sequential_static import SequentialStatic
 
-# TODO: This collection should probably be held by the Config object.
-activation_functions = activations.ActivationFunctionSet()
-
-activation_functions.add('sigmoid', activations.sigmoid_activation)
-activation_functions.add('tanh', activations.tanh_activation)
-activation_functions.add('sin', activations.sin_activation)
-activation_functions.add('gauss', activations.gauss_activation)
-activation_functions.add('relu', activations.relu_activation)
-activation_functions.add('identity', activations.identity_activation)
-activation_functions.add('clamped', activations.clamped_activation)
-activation_functions.add('inv', activations.inv_activation)
-activation_functions.add('log', activations.log_activation)
-activation_functions.add('exp', activations.exp_activation)
-activation_functions.add('abs', activations.abs_activation)
-activation_functions.add('hat', activations.hat_activation)
-activation_functions.add('square', activations.square_activation)
-activation_functions.add('cube', activations.cube_activation)

neat/activations.py

@@ -72,7 +72,20 @@ class InvalidActivationFunction(Exception):
 
 class ActivationFunctionSet(object):
     def __init__(self):
-        self.functions = {}
+        self.functions = {'sigmoid': sigmoid_activation,
+                          'tanh': tanh_activation,
+                          'sin': sin_activation,
+                          'gauss': gauss_activation,
+                          'relu': relu_activation,
+                          'identity': identity_activation,
+                          'clamped': clamped_activation,
+                          'inv': inv_activation,
+                          'log': log_activation,
+                          'exp': exp_activation,
+                          'abs': abs_activation,
+                          'hat': hat_activation,
+                          'square': square_activation,
+                          'cube': cube_activation}
 
     def add(self, config_name, function):
         # TODO: Verify that the given function has the correct signature.
@@ -86,6 +99,7 @@ def get(self, config_name):
         return f
 
     def is_valid(self, config_name):
+        # TODO: Verify that the given function has the correct signature.
         return config_name in self.functions
 
 

neat/config.py

@@ -1,8 +1,8 @@
-from random import random, gauss, choice
 import os
+from random import random, gauss, choice
 
-from neat.genome import DefaultGenome, FFGenome
-from neat import activation_functions
+from neat.activations import ActivationFunctionSet
+from neat.genome import DefaultGenome
 from neat.reproduction import DefaultReproduction
 from neat.stagnation import DefaultStagnation
 
@@ -13,6 +13,7 @@
 
 aggregation_function_defs = {'sum': sum, 'max': max, 'min': min}
 
+
 class Config(object):
     '''
     A simple container for all of the user-configurable parameters of NEAT.
@@ -29,14 +30,81 @@ class Config(object):
 
     allowed_connectivity = ['unconnected', 'fs_neat', 'fully_connected', 'partial']
 
-    def __init__(self, filename=None):
+    def __init__(self):
+        # Initialize type registry with default implementations.
         self.registry = {'DefaultStagnation': DefaultStagnation,
                          'DefaultReproduction': DefaultReproduction,
-                         'DefaultGenome': DefaultGenome,
-                         'FFGenome': FFGenome}
+                         'DefaultGenome': DefaultGenome}
         self.type_config = {}
-        if filename is not None:
-            self.load(filename)
+
+        # Phenotype configuration
+        self.input_nodes = 0
+        self.output_nodes = 0
+        self.hidden_nodes = 0
+        self.initial_connection = 'unconnected'
+        self.connection_fraction = None
+        self.max_weight = 30.0
+        self.min_weight = -30.0
+        self.weight_stdev = 1.0
+        self.activation_functions = ['sigmoid']
+        self.aggregation_functions = ['sum']
+
+        # Genetic algorithm configuration
+        self.pop_size = 150
+        self.max_fitness_threshold = -0.05
+        self.prob_add_conn = 0.5
+        self.prob_add_node = 0.1
+        self.prob_delete_conn = 0.1
+        self.prob_delete_node = 0.05
+        self.prob_mutate_bias = 0.05
+        self.bias_mutation_power = 2.0
+        self.prob_mutate_response = 0.5
+        self.response_mutation_power = 0.1
+        self.prob_mutate_weight = 0.5
+        self.prob_replace_weight = 0.02
+        self.weight_mutation_power = 0.8
+        self.prob_mutate_activation = 0.0
+        self.prob_mutate_aggregation = 0.0
+        self.prob_toggle_link = 0.01
+        self.reset_on_extinction = True
+
+        # genotype compatibility
+        self.compatibility_threshold = 3.0
+        self.excess_coefficient = 1.0
+        self.disjoint_coefficient = 1.0
+        self.weight_coefficient = 0.4
+
+        stagnation_type_name = 'DefaultStagnation'
+        self.stagnation_type = self.registry[stagnation_type_name]
+        # TODO: Look up the default type configuration from a static method on the type?
+        self.type_config[stagnation_type_name] = {'species_fitness_func': 'mean',
+                                                  'max_stagnation': 15}
+
+        reproduction_type_name = 'DefaultReproduction'
+        self.reproduction_type = self.registry[reproduction_type_name]
+        # TODO: Look up the default type configuration from a static method on the type?
+        self.type_config[reproduction_type_name] = {'elitism': 1,
+                                                    'survival_threshold': 0.2}
+
+        genome_type_name = 'DefaultGenome'
+        self.genome_type = self.registry[genome_type_name]
+        # TODO: Look up the default type configuration from a static method on the type?
+        self.type_config[genome_type_name] = {}
+
+        # Gather statistics for each generation.
+        self.collect_statistics = True
+        # Show stats after each generation.
+        self.report = True
+        # Save the best genome from each generation.
+        self.save_best = False
+        # 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
+
+        # Create full set of available activation functions.
+        # TODO: pick a better name for this member, it's too confusing alongside activation_functions.
+        self.available_activations = ActivationFunctionSet()
 
     def load(self, filename):
         if not os.path.isfile(filename):
@@ -76,7 +144,7 @@ def load(self, filename):
 
         # Verify that specified activation functions are valid.
         for fn in self.activation_functions:
-            if not activation_functions.is_valid(fn):
+            if not self.available_activations.is_valid(fn):
                 raise Exception("Invalid activation function name: {0!r}".format(fn))
 
         # Genetic algorithm configuration
@@ -123,28 +191,26 @@ def load(self, filename):
         self.genome_type = self.registry[genome_type_name]
         self.type_config[genome_type_name] = parameters.items(genome_type_name)
 
-        # Gather statistics for each generation.
-        self.collect_statistics = True
-        # Show stats after each generation.
-        self.report = True
-        # Save the best genome from each generation.
-        self.save_best = False
-        # 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 set_input_output_sizes(self, num_inputs, num_outputs):
+        self.input_nodes = num_inputs
+        self.output_nodes = num_outputs
+        self.input_keys = [-i-1 for i in range(self.input_nodes)]
+        self.output_keys = [i for i in range(self.output_nodes)]
+
+    def save(self, filename):
+        pass
 
-    def register(self, typeName, typeDef):
+    def register(self, type_name, type_def):
         """
         User-defined classes mentioned in the config file must be provided to the
         configuration object before the load() method is called.
         """
-        self.registry[typeName] = typeDef
+        self.registry[type_name] = type_def
 
-    def get_type_config(self, typeInstance):
-        return dict(self.type_config[typeInstance.__class__.__name__])
+    def get_type_config(self, type_instance):
+        return dict(self.type_config[type_instance.__class__.__name__])
 
-    # TODO: Factor out these mutation methods into a separate class.
+    # TODO: Factor out these mutation methods into a separate class?
     def new_weight(self):
         return gauss(0, self.weight_stdev)
 

neat/genes.py

@@ -8,6 +8,8 @@ class NodeGene(object):
 
     def __init__(self, key, bias, response, aggregation, activation):
         # TODO: Move these asserts into an external validation mechanism that can be omitted at runtime if desired.
+        #       Maybe this class should implement a validate(config) method that can optionally be called
+        #       by the NEAT framework?
         # TODO: Validate aggregation and activation against current configuration.
         assert type(bias) is float
         assert type(response) is float