This revision is mostly not working. Now with extra violent refactoring/redesign!

 Introduced attributes and config parameters intended to reduce the amount of boilerplate code required for configuration parsing.
Added rough implementation of saving configuration data to file.
Attempted to factor out more common gene/genome behavior.
Change reported genome "size" to just be (# nodes, # active connections).
Added refactoring notes and placeholders in documentation.
Added activation function facility tests.

Author: CodeReclaimers

docs/customization.rst

@@ -32,8 +32,8 @@ it with an object which implements the same interface as `BaseReporter`.
 <https://github.com/CodeReclaimers/neat-python/blob/master/neat/reporting.py#L56>`_ may be useful as examples of the
 behavior you can add using a reporter.
 
-Species stagnation
-------------------
+Species stagnation scheme
+-------------------------
 
 To use a different species stagnation scheme, you must create and register a custom class whose interface matches that
 of `DefaultStagnation` and set the `stagnation_type` of your Config instance to this class.
@@ -49,13 +49,17 @@ is encapsulated in the DefaultReproduction class.
 
 TODO: document, include example
 
+EXAMPLE: ???
+
 Speciation
 ----------
 
 If you need to change the speciation scheme, you should subclass `Population` and override the `_speciate` method (or,
 if you must, `monkey patch/duck punch
 <https://en.wikipedia.org/wiki/Monkey_patch>`_ it).
 
+EXAMPLE: ???
+
 Diversity
 ---------
 
@@ -64,20 +68,35 @@ To use a different diversity scheme, you can create a custom class whose interfa
 
 TODO: document, include example
 
+EXAMPLE: ???
+
 Using different genome types
---------------------------
+----------------------------
 
 To use a different genome type, you can create a custom class whose interface matches that of
 `Genome` or `FFGenome`, and set the `genotype` member of your Config instance to this class.
 
 TODO: document, include example
 
+EXAMPLE: genome with an additional set of genes (used for?)
+
 Using a different gene type
------------------------------
+---------------------------
 
 To use a different gene type, you can create a custom class whose interface matches that of
 `NodeGene` or `ConnectionGene`, and set the `node_gene_type` or `conn_gene_type` member,
 respectively, of your Config instance to this class.
 
 TODO: document, include example
 
+EXAMPLE: ???  reference the IZNN genes?
+
+Using a different network type
+------------------------------
+
+EXAMPLE: ???
+
+Cross-validation
+----------------
+
+EXAMPLE: ???

examples/memory/nn_config

@@ -1,50 +1,59 @@
-# Parameters for the bit-sequence memory 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]
-genome_type       = DefaultGenome
-reproduction_type = DefaultReproduction
-stagnation_type   = DefaultStagnation
+# NEAT configuration for the bit-sequence memory experiment.
 
 # The `NEAT` section specifies parameters particular to the NEAT algorithm
-# or the experiment itself.
+# or the experiment itself.  This is the only required section.
 [NEAT]
 pop_size              = 150
 max_fitness_threshold = -0.05
 reset_on_extinction   = 0
+collect_statistics = True
+report = True
+save_best = False
 
 [DefaultGenome]
 num_inputs              = 2
 num_hidden              = 0
 num_outputs             = 1
 initial_connection      = partial 0.5
 feed_forward            = 0
-activation              = clamped sigmoid tanh my_sinc_function
-aggregation             = sum
+compatibility_threshold = 3.0
+excess_coefficient      = 1.0
+disjoint_coefficient    = 1.0
+weight_coefficient      = 0.5
 conn_add_prob           = 0.5
 conn_delete_prob        = 0.25
 node_add_prob           = 0.5
 node_delete_prob        = 0.25
-bias_mutate_prob        = 0.8
+activation_default      = sigmoid
+activation_options      = clamped sigmoid tanh my_sinc_function
+activation_mutate_rate  = 0.02
+aggregation_default     = sum
+aggregation_options     = sum
+aggregation_mutate_rate = 0.0
+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
-response_mutate_prob    = 0.8
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+response_init_mean      = 0.0
+response_init_stdev     = 1.0
+response_replace_rate   = 0.1
+response_mutate_rate    = 0.7
 response_mutate_power   = 0.5
-weight_max              = 30
-weight_min              = -30
-weight_mean             = 0.0
-weight_stdev            = 1.0
-weight_mutate_prob      = 0.8
-weight_replace_prob     = 0.1
+response_max_value      = 30.0
+response_min_value      = -30.0
+
+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
-activation_mutate_prob  = 0.002
-aggregation_mutate_prob = 0.0
-link_toggle_prob        = 0.01
-compatibility_threshold = 3.0
-excess_coefficient      = 1.0
-disjoint_coefficient    = 1.0
-weight_coefficient      = 0.5
+enabled_default         = True
+enabled_mutate_rate     = 0.01
 
 [DefaultStagnation]
 species_fitness = median

examples/memory/nn_evolve.py

@@ -14,6 +14,9 @@
 
 from neat.config import Config
 from neat import nn, population, statistics, parallel
+from neat.genome import DefaultGenome
+from neat.reproduction import DefaultReproduction
+from neat.stagnation import DefaultStagnation
 
 # num_tests is the number of random examples each network is tested against.
 num_tests = 16
@@ -59,13 +62,15 @@ def run():
     # Determine path to configuration file.
     local_dir = os.path.dirname(__file__)
     config_path = os.path.join(local_dir, 'nn_config')
-    config = Config(config_path)
+    config = Config(DefaultGenome, DefaultReproduction, DefaultStagnation, config_path)
+
+    config.save('test_save_config.txt')
 
     # This sinc function will be available if my_sinc_function is included in the
     # config file activation_functions option under the pheotype section.
     # Note that sinc is not necessarily useful for this example, it was chosen
     # arbitrarily just to demonstrate adding a custom activation function.
-    config.genome_config.activation_defs.add('my_sinc_function', sinc)
+    config.genome_config.add_activation('my_sinc_function', sinc)
 
     pop = population.Population(config)
     #pe = parallel.ParallelEvaluator(4, eval_fitness)

neat/attributes.py

@@ -0,0 +1,120 @@
+from random import choice, gauss, random
+from neat.config import ConfigParameter
+
+# TODO: There is probably a lot of room for simplification of these classes using metaprogramming.
+
+class BaseAttribute(object):
+    def __init__(self, name):
+        self.name = name
+        for n, cname in zip(self.__config_items__, self.config_item_names()):
+            setattr(self, n + "_name", cname)
+
+    def config_item_names(self):
+        return ["{0}_{1}".format(self.name, i) for i in self.__config_items__]
+
+
+class FloatAttribute(BaseAttribute):
+    __config_items__ = ["init_mean",
+                        "init_stdev",
+                        "replace_rate",
+                        "mutate_rate",
+                        "mutate_power",
+                        "max_value",
+                        "min_value"]
+
+    def get_config_params(self):
+        return [ConfigParameter(n, float) for n in self.config_item_names()]
+
+    def clamp(self, value, config):
+        min_value = getattr(config, self.min_value_name)
+        max_value = getattr(config, self.max_value_name)
+        return max(min(value, max_value), min_value)
+
+    def init_value(self, config):
+        mean = getattr(config, self.init_mean_name)
+        stdev = getattr(config, self.init_stdev_name)
+        return self.clamp(gauss(mean, stdev), config)
+
+    def mutate_value(self, value, config):
+        replace_rate = getattr(config, self.replace_rate_name)
+
+        r = random()
+        if r < replace_rate:
+            return self.init_value(config)
+
+        mutate_rate = getattr(config, self.mutate_rate_name)
+        if r < replace_rate + mutate_rate:
+            mutate_power = getattr(config, self.mutate_power_name)
+            return value + gauss(0.0, mutate_power)
+
+        return self.clamp(value, config)
+
+    def validate(self, config):
+        pass
+
+
+class BoolAttribute(BaseAttribute):
+    __config_items__ = ["default",
+                        "mutate_rate"]
+
+    def get_config_params(self):
+        default_name, rate_name = self.config_item_names()
+        return [ConfigParameter(default_name, bool), ConfigParameter(rate_name, float)]
+
+    def init_value(self, config):
+        default = getattr(config, self.default_name)
+
+        if default is None:
+            return random() < 0.5
+
+        return default
+
+    def mutate_value(self, value, config):
+        mutate_rate = getattr(config, self.mutate_rate_name)
+
+        r = random()
+        if r < mutate_rate:
+            # NOTE: we choose a random value here so that the mutation rate has the
+            # same exact meaning as the rates given for the string and bool
+            # attributes (the mutation operation *may* change the value but is not
+            # guaranteed to do so).
+            return random() < 0.5
+
+        return value
+
+    def validate(self, config):
+        pass
+
+
+class StringAttribute(BaseAttribute):
+    __config_items__ = ["default",
+                        "options",
+                        "mutate_rate"]
+
+    def get_config_params(self):
+        default_name, opt_name, rate_name = self.config_item_names()
+        return [ConfigParameter(default_name, str),
+                ConfigParameter(opt_name, list),
+                ConfigParameter(rate_name, float)]
+
+    def init_value(self, config):
+        default = getattr(config, self.default_name)
+
+        if default is None:
+            options = getattr(config, self.options_name)
+            return choice(options)
+
+        return default
+
+    def mutate_value(self, value, config):
+        mutate_rate = getattr(config, self.mutate_rate_name)
+
+        r = random()
+        if r < mutate_rate:
+            options = getattr(config, self.options_name)
+            return choice(options)
+
+        return value
+
+    def validate(self, config):
+        pass