ActivationFunctionSet now uses its own add method to add the default set of functions.

Added minimal type validation for Config initializer types.
Updated add_hidden_nodes to work with current implementation.

Author: CodeReclaimers

neat/activations.py

@@ -82,31 +82,32 @@ def validate_activation(function):
 
 class ActivationFunctionSet(object):
     def __init__(self):
-        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):
+        self.functions = {}
+        self.add('sigmoid', sigmoid_activation)
+        self.add('tanh', tanh_activation)
+        self.add('sin', sin_activation)
+        self.add('gauss', gauss_activation)
+        self.add('relu', relu_activation)
+        self.add('identity', identity_activation)
+        self.add('clamped', clamped_activation)
+        self.add('inv', inv_activation)
+        self.add('log', log_activation)
+        self.add('exp', exp_activation)
+        self.add('abs', abs_activation)
+        self.add('hat', hat_activation)
+        self.add('square', square_activation)
+        self.add('cube', cube_activation)
+
+    def add(self, name, function):
         validate_activation(function)
-        self.functions[config_name] = function
+        self.functions[name] = function
 
-    def get(self, config_name):
-        f = self.functions.get(config_name)
+    def get(self, name):
+        f = self.functions.get(name)
         if f is None:
-            raise InvalidActivationFunction("No such function: {0!r}".format(config_name))
+            raise InvalidActivationFunction("No such activation function: {0!r}".format(name))
 
         return f
 
-    def is_valid(self, config_name):
-        return config_name in self.functions
+    def is_valid(self, name):
+        return name in self.functions

neat/config.py

@@ -67,9 +67,7 @@ def write_pretty_params(f, config, params):
 
 
 class Config(object):
-    '''
-    A simple container for all of the user-configurable parameters of NEAT.
-    '''
+    ''' A simple container for user-configurable parameters of NEAT. '''
 
     __params = [ConfigParameter('pop_size', int),
                 ConfigParameter('max_fitness_threshold', float),
@@ -79,14 +77,19 @@ class Config(object):
                 ConfigParameter('save_best', bool)]
 
     def __init__(self, genome_type, reproduction_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(stagnation_type, 'parse_config')
+
         self.genome_type = genome_type
         self.stagnation_type = stagnation_type
         self.reproduction_type = reproduction_type
 
         if not os.path.isfile(filename):
             raise Exception('No such config file: ' + os.path.abspath(filename))
-        parameters = ConfigParser()
 
+        parameters = ConfigParser()
         with open(filename) as f:
             if hasattr(parameters, 'read_file'):
                 parameters.read_file(f)

neat/genome.py

@@ -30,12 +30,6 @@ def __init__(self, params):
         # Create full set of available activation functions.
         self.activation_defs = ActivationFunctionSet()
         self.activation_options = params.get('activation_options', 'sigmoid').strip().split()
-
-        # TODO: Verify that specified activation functions are valid before using them.
-        # for fn in self.activation:
-        #     if not self.activation_defs.is_valid(fn):
-        #         raise Exception("Invalid activation function name: {0!r}".format(fn))
-
         self.aggregation_options = params.get('aggregation_options', 'sum').strip().split()
 
         # Gather configuration data from the gene classes.
@@ -195,7 +189,7 @@ def inherit_genes(self, parent1, parent2):
                 # Homologous gene: combine genes from both parents.
                 self.nodes[key] = ng1.crossover(ng2)
 
-    def get_new_hidden_id(self):
+    def get_new_node_key(self):
         new_id = 0
         while new_id in self.nodes:
             new_id += 1
@@ -207,7 +201,7 @@ def mutate_add_node(self, config):
 
         # Choose a random connection to split
         conn_to_split = choice(list(self.connections.values()))
-        new_node_id = self.get_new_hidden_id()
+        new_node_id = self.get_new_node_key()
         ng = self.create_node(config, new_node_id)
         self.nodes[new_node_id] = ng
 
@@ -380,23 +374,20 @@ def __str__(self):
             s += "\n\t" + str(c)
         return s
 
-    def add_hidden_nodes(self, num_hidden, config):
-        node_id = self.get_new_hidden_id()
-        for i in range(num_hidden):
-            # TODO: factor out new node creation.
-            act_func = choice(config.activation)
-            node_gene = config.node_gene_type(activation_type=act_func)
-            assert node_id not in self.hidden
-            self.hidden[node_id] = node_gene
-            node_id += 1
+    def add_hidden_nodes(self, config):
+        for i in range(config.num_hidden):
+            node_key = self.get_new_node_key()
+            assert node_key not in self.nodes
+            node = self.__class__.create_node(config, node_key)
+            self.nodes[node_key] = node
 
     @classmethod
     def create(cls, config, key):
         g = cls.create_unconnected(config, key)
 
         # Add hidden nodes if requested.
         if config.num_hidden > 0:
-            g.add_hidden_nodes(config.num_hidden)
+            g.add_hidden_nodes(config)
 
         # Add connections based on initial connectivity type.
         if config.initial_connection == 'fs_neat':