More refactoring.

Refactoring of statistics handling.
Added FFGenome test.
Added temporary debugging code.
Renamed Genome to DefaultGenome.
Removed 'feedforward' configuration item in favor of explicitly specifying a genome type.
Fixed Config.new_activation bug that chose from all functions instead of the ones specified in the config file.
Fixed accidental double usage of mutation probabilities in NodeGene.mutate.
Added refactoring reminder comments.
Restored keys (formerly called ID) to species/genome/gene class instances because tracking ids separately is more painful.

Author: CodeReclaimers

examples/xor/xor2_config

@@ -6,6 +6,7 @@
 [Types]
 stagnation_type      = DefaultStagnation
 reproduction_type    = DefaultReproduction
+genome_type          = DefaultGenome
 
 [phenotype]
 input_nodes          = 2
@@ -14,11 +15,12 @@ output_nodes         = 1
 initial_connection   = unconnected
 max_weight           = 30
 min_weight           = -30
-feedforward          = 1
 activation_functions = sigmoid
 aggregation_functions = sum
 weight_stdev         = 1.0
 
+[FFGenome]
+
 [genetic]
 pop_size                = 150
 max_fitness_threshold   = 0.95

neat/config.py

@@ -1,7 +1,7 @@
 from random import random, gauss, choice
 import os
 
-from neat.genome import Genome, FFGenome
+from neat.genome import DefaultGenome, FFGenome
 from neat import activation_functions
 from neat.reproduction import DefaultReproduction
 from neat.stagnation import DefaultStagnation
@@ -31,7 +31,9 @@ class Config(object):
 
     def __init__(self, filename=None):
         self.registry = {'DefaultStagnation': DefaultStagnation,
-                         'DefaultReproduction': DefaultReproduction}
+                         'DefaultReproduction': DefaultReproduction,
+                         'DefaultGenome': DefaultGenome,
+                         'FFGenome': FFGenome}
         self.type_config = {}
         if filename is not None:
             self.load(filename)
@@ -58,7 +60,6 @@ def load(self, filename):
         self.connection_fraction = None
         self.max_weight = float(parameters.get('phenotype', 'max_weight'))
         self.min_weight = float(parameters.get('phenotype', 'min_weight'))
-        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()
@@ -78,12 +79,6 @@ def load(self, filename):
             if not activation_functions.is_valid(fn):
                 raise Exception("Invalid activation function name: {0!r}".format(fn))
 
-        # Select a genotype class.
-        if self.feedforward:
-            self.genotype = FFGenome
-        else:
-            self.genotype = Genome
-
         # Genetic algorithm configuration
         self.pop_size = int(parameters.get('genetic', 'pop_size'))
         self.max_fitness_threshold = float(parameters.get('genetic', 'max_fitness_threshold'))
@@ -111,6 +106,7 @@ def load(self, filename):
 
         stagnation_type_name = parameters.get('Types', 'stagnation_type')
         reproduction_type_name = parameters.get('Types', 'reproduction_type')
+        genome_type_name = parameters.get('Types', 'genome_type')
 
         if stagnation_type_name not in self.registry:
             raise Exception('Unknown stagnation type: {!r}'.format(stagnation_type_name))
@@ -122,6 +118,11 @@ def load(self, filename):
         self.reproduction_type = self.registry[reproduction_type_name]
         self.type_config[reproduction_type_name] = parameters.items(reproduction_type_name)
 
+        if genome_type_name not in self.registry:
+            raise Exception('Unknown reproduction type: {!r}'.format(reproduction_type_name))
+        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.
@@ -151,13 +152,13 @@ def new_bias(self):
         return gauss(0, self.weight_stdev)
 
     def new_response(self):
-        return 1.0
+        return 5.0
 
     def new_aggregation(self):
         return choice(self.aggregation_functions)
 
     def new_activation(self):
-        return choice(list(activation_functions.functions.keys()))
+        return choice(self.activation_functions)
 
     def mutate_weight(self, weight):
         if random() < self.prob_mutate_weight:

neat/genes.py

@@ -45,17 +45,10 @@ def copy(self):
 
     # TODO: Factor out mutation into a separate class.
     def mutate(self, config):
-        if random() < config.prob_mutate_bias:
-            self.bias = config.mutate_bias(self.bias)
-
-        if random() < config.prob_mutate_response:
-            self.response = config.mutate_response(self.response)
-
-        if random() < config.prob_mutate_aggregation:
-            self.aggregation = config.mutate_aggregation(self.aggregation)
-
-        if random() < config.prob_mutate_activation:
-            self.activation = config.mutate_activation(self.activation)
+        self.bias = config.mutate_bias(self.bias)
+        self.response = config.mutate_response(self.response)
+        self.aggregation = config.mutate_aggregation(self.aggregation)
+        self.activation = config.mutate_activation(self.activation)
 
 
 # TODO: Evaluate using __slots__ for performance/memory usage improvement.

neat/genome.py

@@ -5,12 +5,13 @@
 from random import choice, gauss, randint, random, shuffle
 
 
-class Genome(object):
+class DefaultGenome(object):
     """ A genome for generalized neural networks. """
 
     def __init__(self, key):
-        # (id, gene) pairs for gene sets.
         self.key = key
+
+        # (id, gene) pairs for gene sets.
         self.connections = {}
         self.hidden = {}
         self.inputs = {}
@@ -54,11 +55,6 @@ def mutate(self, config):
 
     def crossover(self, other, key):
         """ Crosses over parents' genomes and returns a child. """
-
-        # Parents must belong to the same species.
-        #assert self.species_id == other.species_id, 'Different parents species ID: {0} vs {1}'.format(self.species_id,
-        #                                                                                              other.species_id)
-
         if self.fitness > other.fitness:
             parent1 = self
             parent2 = other
@@ -68,11 +64,8 @@ def crossover(self, other, key):
 
         # creates a new child
         child = self.__class__(key)
-
         child.inherit_genes(parent1, parent2)
 
-        #child.species_id = parent1.species_id
-
         return child
 
     def inherit_genes(self, parent1, parent2):
@@ -288,7 +281,7 @@ def add_hidden_nodes(self, num_hidden, config):
 
     @classmethod
     def create(cls, config, key):
-        g = config.genotype.create_unconnected(config, key)
+        g = config.genome_type.create_unconnected(config, key)
 
         # Add hidden nodes if requested.
         if config.hidden_nodes > 0:
@@ -376,7 +369,11 @@ def connect_partial(self, config):
 
 
 
-class FFGenome(Genome):
+# TODO: This class only differs from DefaultGenome in mutation behavior and
+# the node_order member.  Its complexity suggests the bar is set too high
+# for creating user-defined genome types.
+
+class FFGenome(DefaultGenome):
     """ A genome for feed-forward neural networks. Feed-forward
         topologies are a particular case of Recurrent NNs.
     """

neat/nn/__init__.py

@@ -2,6 +2,7 @@
 
 from neat import activation_functions
 from neat.six_util import iterkeys, itervalues
+from neat.config import aggregation_function_defs
 
 
 def find_feed_forward_layers(inputs, connections):
@@ -50,11 +51,15 @@ def serial_activate(self, inputs):
         for i, v in zip(self.input_nodes, inputs):
             self.values[i] = v
 
-        for node, func, bias, response, links in self.node_evals:
-            s = 0.0
+        for node, agg_func, act_func, bias, response, links in self.node_evals:
+            #print(node, func, bias, response, links)
+            node_inputs = []
             for i, w in links:
-                s += self.values[i] * w
-            self.values[node] = func(bias + response * s)
+                node_inputs.append(self.values[i] * w)
+            s = agg_func(node_inputs)
+            self.values[node] = act_func(bias + response * s)
+            print("  v[{}] = {}({} + {} * {} = {}) = {}".format(node, act_func, bias, response, s, bias + response * s, self.values[node]))
+        print(self.values)
 
         return [self.values[i] for i in self.output_nodes]
 
@@ -74,23 +79,25 @@ def create_feed_forward_phenotype(genome):
 
     layers = find_feed_forward_layers(input_nodes, connections)
     node_evals = []
-    #used_nodes = set(input_nodes + output_nodes)
     max_used_node = max(max(input_nodes), max(output_nodes))
     for layer in layers:
         for node in layer:
             inputs = []
+            node_expr = []
             # TODO: This could be more efficient.
             for cg in itervalues(genome.connections):
                 if cg.output == node and cg.enabled:
                     inputs.append((cg.input, cg.weight))
-                    #used_nodes.add(cg.in_node_id)
+                    node_expr.append("v[%d] * %f" % (cg.input, cg.weight))
                     max_used_node = max(max_used_node, cg.input)
 
-            #used_nodes.add(node)
             max_used_node = max(max_used_node, node)
             ng = all_nodes[node]
+            aggregation_function = aggregation_function_defs[ng.aggregation]
             activation_function = activation_functions.get(ng.activation)
-            node_evals.append((node, activation_function, ng.bias, ng.response, inputs))
+            node_evals.append((node, aggregation_function, activation_function, ng.bias, ng.response, inputs))
+
+            print("  v[%d] = %s(%f + %f * %s(%s))" % (node, ng.activation, ng.bias, ng.response, ng.aggregation, ", ".join(node_expr)))
 
     return FeedForwardNetwork(max_used_node, input_nodes, output_nodes, node_evals)
 

neat/population.py

@@ -7,7 +7,8 @@
 import time
 
 from neat.config import Config
-from neat.reporting import ReporterSet, StatisticsReporter, StdOutReporter
+from neat.reporting import ReporterSet, StdOutReporter
+from neat.statistics import StatisticsReporter
 from neat.species import SpeciesSet
 from neat.six_util import iteritems, itervalues
 
@@ -120,18 +121,16 @@ def run(self, fitness_function, n):
             # genome doesn't change--in these cases, evaluating unmodified elites in each
             # generation is a waste of time.  The user can always take care of this in their
             # fitness function in the time being if they wish.
-            fitness_function(list(iteritems(self.population)))
+            fitness_function(list(itervalues(self.population)))
             #self.total_evaluations += len(self.population)
 
             # Gather and report statistics.
-            best_id = None
             best = None
             best_fitness = -sys.float_info.max
-            for k, v in iteritems(self.population):
-                if v.fitness > best_fitness:
-                    best = v
-                    best_id = k
-            self.reporters.post_evaluate(self.population, self.species, best_id, best)
+            for g in itervalues(self.population):
+                if g.fitness > best_fitness:
+                    best = g
+            self.reporters.post_evaluate(self.population, self.species, best)
 
             # Save the best genome from the current generation if requested.
             if self.config.save_best:

neat/reporting.py

@@ -1,11 +1,9 @@
 from __future__ import print_function
 
-import copy
 import time
-import sys
 
 from neat.math_util import mean, stdev
-from neat.six_util import iteritems, itervalues
+from neat.six_util import itervalues
 
 
 class ReporterSet(object):
@@ -34,9 +32,9 @@ def saving_checkpoint(self, checkpoint_type, filename):
         for r in self.reporters:
             r.saving_checkpoint(checkpoint_type, filename)
 
-    def post_evaluate(self, population, species, best_id, best):
+    def post_evaluate(self, population, species, best_genome):
         for r in self.reporters:
-            r.post_evaluate(population, species, best_id, best)
+            r.post_evaluate(population, species, best_genome)
 
     def complete_extinction(self):
         for r in self.reporters:
@@ -69,7 +67,7 @@ def loading_checkpoint(self, filename):
     def saving_checkpoint(self, checkpoint_type, filename):
         pass
 
-    def post_evaluate(self, population, species, best_id, best):
+    def post_evaluate(self, population, species, best_genome):
         pass
 
     def complete_extinction(self):
@@ -105,14 +103,14 @@ def saving_checkpoint(self, checkpoint_type, filename):
         print('Creating {0} checkpoint file {1} at generation: {0}'.format(
             checkpoint_type, filename, self.generation))
 
-    def post_evaluate(self, population, species, best_id, best):
+    def post_evaluate(self, population, species, best_genome):
         fitnesses = [c.fitness for c in itervalues(population)]
         fit_mean = mean(fitnesses)
         fit_std = stdev(fitnesses)
-        best_species_id = species.get_species_id(best_id)
+        best_species_id = species.get_species_id(best_genome.key)
         print('Population\'s average fitness: {0:3.5f} stdev: {1:3.5f}'.format(fit_mean, fit_std))
-        print('Best fitness: {0:3.5f} - size: {1!r} - species {2} - id {3}'.format(best.fitness, best.size(),
-                                                                                   best_species_id, best_id))
+        print('Best fitness: {0:3.5f} - size: {1!r} - species {2} - id {3}'.format(best_genome.fitness, best_genome.size(),
+                                                                                   best_species_id, best_genome.key))
         print('Species length: {0:d} totaling {1:d} individuals'.format(len(species.species), len(population)))
         #print('Species ID       : {0!s}'.format([s.ID for s in species]))
         #print('Species size     : {0!s}'.format([len(s.members) for s in species]))
@@ -130,69 +128,3 @@ def species_stagnant(self, sid, species):
 
     def info(self, msg):
         print(msg)
-
-
-class StatisticsReporter(BaseReporter):
-    def __init__(self):
-        BaseReporter.__init__(self)
-        self.most_fit_genomes = []
-        self.generation_statistics = []
-        self.generation_cross_validation_statistics = []
-
-    def post_evaluate(self, population, species, best_id, best):
-        self.most_fit_genomes.append(copy.deepcopy(best))
-
-        # Store the fitnesses of the members of each currently active species.
-        species_stats = {}
-        species_cross_validation_stats = {}
-        for sid, s in iteritems(species.species):
-            species_stats[sid] = dict((k, v.fitness) for k, v in iteritems(s.members))
-            species_cross_validation_stats[sid] = dict((k, v.cross_fitness) for k, v in iteritems(s.members))
-        self.generation_statistics.append(species_stats)
-        self.generation_cross_validation_statistics.append(species_cross_validation_stats)
-
-    def get_average_fitness(self):
-        """Get the per-generation average fitness."""
-        avg_fitness = []
-        for stats in self.generation_statistics:
-            scores = []
-            for fitness in stats.values():
-                scores.extend(fitness)
-            avg_fitness.append(mean(scores))
-
-        return avg_fitness
-
-    def get_average_cross_validation_fitness(self):
-        """Get the per-generation average cross_validation fitness."""
-        avg_cross_validation_fitness = []
-        for stats in self.generation_cross_validation_statistics:
-            scores = []
-            for fitness in stats.values():
-                scores.extend(fitness)
-            avg_cross_validation_fitness.append(mean(scores))
-
-        return avg_cross_validation_fitness
-
-    def best_unique_genomes(self, n):
-        """Returns the most n fit genomes, with no duplication."""
-        best_unique = {}
-        for g in self.most_fit_genomes:
-            best_unique[g.ID] = g
-        best_unique = list(best_unique.values())
-
-        def key(genome):
-            return genome.fitness
-
-        return sorted(best_unique, key=key, reverse=True)[:n]
-
-    def best_genomes(self, n):
-        """Returns the n most fit genomes ever seen."""
-        def key(g):
-            return g.fitness
-
-        return sorted(self.most_fit_genomes, key=key, reverse=True)[:n]
-
-    def best_genome(self):
-        """Returns the most fit genome ever seen."""
-        return self.best_genomes(1)[0]
-