First pass on aggressive refactoring and simplification.

Added option to have (mutable) node aggregation functions other than summation.
Keep input, output, and hidden node genes in separate containers.
Noted issues that should be addressed in future refactoring.

Author: CodeReclaimers

examples/memory/nn_config

@@ -16,6 +16,7 @@ max_weight           = 30
 min_weight           = -30
 feedforward          = 0
 activation_functions = clamped sigmoid tanh my_sinc_function
+aggregation_functions = sum
 weight_stdev         = 1.0
 
 [genetic]
@@ -33,6 +34,7 @@ prob_mutate_weight      = 0.8
 prob_replace_weight     = 0.1
 weight_mutation_power   = 0.5
 prob_mutate_activation  = 0.002
+prob_mutate_aggregation = 0.0
 prob_toggle_link        = 0.01
 reset_on_extinction     = 1
 

examples/memory/nn_evolve.py

@@ -20,8 +20,8 @@
 N = 4
 
 
-def eval_fitness(g):
-    net = nn.create_recurrent_phenotype(g)
+def eval_fitness(genome_id, genome):
+    net = nn.create_recurrent_phenotype(genome)
 
     error = 0.0
     for _ in range(num_tests):
@@ -43,6 +43,11 @@ def eval_fitness(g):
     return -(error / (N * num_tests)) ** 0.5
 
 
+def eval_genomes(genomes):
+    for genome_id, genome in genomes:
+        genome.fitness = eval_fitness(genome_id, genome)
+
+
 # Demonstration of how to add your own custom activation function.
 def sinc(x):
     return 1.0 if x == 0 else math.sin(x) / x
@@ -57,8 +62,9 @@ def sinc(x):
 def run():
     local_dir = os.path.dirname(__file__)
     pop = population.Population(os.path.join(local_dir, 'nn_config'))
-    pe = parallel.ParallelEvaluator(4, eval_fitness)
-    pop.run(pe.evaluate, 1000)
+    #pe = parallel.ParallelEvaluator(4, eval_fitness)
+    #pop.run(pe.evaluate, 1000)
+    pop.run(eval_genomes, 1000)
 
     # Log statistics.
     statistics.save_stats(pop.statistics)

examples/xor/xor2.py

@@ -5,13 +5,42 @@
 
 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]))
+
+
+
+total_evaluations = 0
 
 def eval_fitness(genomes):
-    for g in 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
@@ -35,7 +64,7 @@ def eval_fitness(genomes):
 statistics.save_species_count(pop.statistics)
 statistics.save_species_fitness(pop.statistics)
 
-print('Number of evaluations: {0}'.format(pop.total_evaluations))
+print('Number of evaluations: {0}'.format(total_evaluations))
 
 # Show output of the most fit genome against training data.
 winner = pop.statistics.best_genome()

examples/xor/xor2_config

@@ -16,6 +16,7 @@ max_weight           = 30
 min_weight           = -30
 feedforward          = 1
 activation_functions = sigmoid
+aggregation_functions = sum
 weight_stdev         = 1.0
 
 [genetic]
@@ -33,6 +34,7 @@ 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
 

neat/__init__.py

@@ -1,5 +1,6 @@
 from neat import activations
 
+# TODO: This collection should probably be held by the Config object.
 activation_functions = activations.ActivationFunctionSet()
 
 activation_functions.add('sigmoid', activations.sigmoid_activation)

neat/config.py

@@ -1,6 +1,6 @@
+from random import random, gauss, choice
 import os
 
-from neat.genes import NodeGene, ConnectionGene
 from neat.genome import Genome, FFGenome
 from neat import activation_functions
 from neat.reproduction import DefaultReproduction
@@ -11,6 +11,7 @@
 except ImportError:
     from ConfigParser import SafeConfigParser as ConfigParser
 
+aggregation_function_defs = {'sum': sum, 'max': max, 'min': min}
 
 class Config(object):
     '''
@@ -60,6 +61,7 @@ def load(self, filename):
         self.feedforward = bool(int(parameters.get('phenotype', 'feedforward')))
         self.weight_stdev = float(parameters.get('phenotype', 'weight_stdev'))
         self.activation_functions = parameters.get('phenotype', 'activation_functions').strip().split()
+        self.aggregation_functions = parameters.get('phenotype', 'aggregation_functions').strip().split()
 
         # Verify that initial connection type is valid.
         if 'partial' in self.initial_connection:
@@ -97,6 +99,7 @@ def load(self, filename):
         self.prob_replace_weight = float(parameters.get('genetic', 'prob_replace_weight'))
         self.weight_mutation_power = float(parameters.get('genetic', 'weight_mutation_power'))
         self.prob_mutate_activation = float(parameters.get('genetic', 'prob_mutate_activation'))
+        self.prob_mutate_aggregation = float(parameters.get('genetic', 'prob_mutate_aggregation'))
         self.prob_toggle_link = float(parameters.get('genetic', 'prob_toggle_link'))
         self.reset_on_extinction = bool(int(parameters.get('genetic', 'reset_on_extinction')))
 
@@ -106,10 +109,6 @@ def load(self, filename):
         self.disjoint_coefficient = float(parameters.get('genotype compatibility', 'disjoint_coefficient'))
         self.weight_coefficient = float(parameters.get('genotype compatibility', 'weight_coefficient'))
 
-        # Gene types
-        self.node_gene_type = NodeGene
-        self.conn_gene_type = ConnectionGene
-
         stagnation_type_name = parameters.get('Types', 'stagnation_type')
         reproduction_type_name = parameters.get('Types', 'reproduction_type')
 
@@ -142,4 +141,58 @@ def register(self, typeName, typeDef):
         self.registry[typeName] = typeDef
 
     def get_type_config(self, typeInstance):
-        return dict(self.type_config[typeInstance.__class__.__name__])
+        return dict(self.type_config[typeInstance.__class__.__name__])
+
+    # TODO: Factor out these mutation methods into a separate class.
+    def new_weight(self):
+        return gauss(0, self.weight_stdev)
+
+    def new_bias(self):
+        return gauss(0, self.weight_stdev)
+
+    def new_response(self):
+        return 1.0
+
+    def new_aggregation(self):
+        return choice(self.aggregation_functions)
+
+    def new_activation(self):
+        return choice(list(activation_functions.functions.keys()))
+
+    def mutate_weight(self, weight):
+        if random() < self.prob_mutate_weight:
+            if random() < self.prob_replace_weight:
+                # Replace weight with a random value.
+                weight = self.new_weight()
+            else:
+                # Perturb weight.
+                weight += gauss(0, self.weight_mutation_power)
+                weight = max(self.min_weight, min(self.max_weight, weight))
+
+        return weight
+
+    def mutate_bias(self, bias):
+        if random() < self.prob_mutate_bias:
+            bias += gauss(0, self.bias_mutation_power)
+            bias = max(self.min_weight, min(self.max_weight, bias))
+
+        return bias
+
+    def mutate_response(self, response):
+        if random() < self.prob_mutate_response:
+            response += gauss(0, self.response_mutation_power)
+            response = max(self.min_weight, min(self.max_weight, response))
+
+        return response
+
+    def mutate_aggregation(self, aggregation):
+        if random() < self.prob_mutate_aggregation:
+            aggregation = self.new_aggregation()
+
+        return aggregation
+
+    def mutate_activation(self, activation):
+        if random() < self.prob_mutate_activation:
+            activation = self.new_activation()
+
+        return activation

neat/ctrnn/__init__.py

@@ -14,9 +14,9 @@ class CTNodeGene(NodeGene):
         The main difference here is the addition of
         a decay rate given by the time constant.
     """
-    def __init__(self, ID, node_type, bias=0.0, response=4.924273,
+    def __init__(self, ID, bias=0.0, response=4.924273,
                  activation_type='sigmoid', time_constant=1.0):
-        super(CTNodeGene, self).__init__(ID, node_type, bias, response, activation_type)
+        super(CTNodeGene, self).__init__(ID, bias, response, activation_type)
         self.time_constant = time_constant
 
     def mutate(self, config):