Updated documentation and examples.

Fixed bug in statistics reporter.

Author: CodeReclaimers

docs/activation.rst

@@ -1,9 +1,10 @@
+.. _activation-functions-label:
 
 Overview of builtin activation functions
 ========================================
 
-The implementation of these functions can be found in the `nn module
-<https://github.com/CodeReclaimers/neat-python/blob/master/neat/nn/__init__.py>`_.
+The implementation of these functions can be found in the `activations module
+<https://github.com/CodeReclaimers/neat-python/blob/master/neat/activations.py>`_.
 
 abs
 ---

docs/config_file.rst

@@ -64,7 +64,7 @@ required for your particular implementation.
     The probability that mutation will change the node's activation function. Valid values are on [0.0, 1.0].
 * *activation_options*
     A space-separated list of the activation functions that may be used in constructing networks.  The
-    set of available functions can be found here: .. _`activation`:
+    set of available functions can be found here: :ref:`activation-functions-label`
 
 * *aggregation_default*
     The default aggregation function assigned to new nodes.

examples/README.md

@@ -0,0 +1,17 @@
+## neat-python examples ##
+
+Note that there is a significant amount of duplication between these scripts, and this is intentional.  The goal is to 
+make it easier to see what the example is doing, without making the user dig through a bunch of code that is not 
+directly related to the NEAT library usage.
+
+## The examples ##
+
+* `circuits` Uses an external circuit simulator (PySpice) to create electronic circuits that reproduce an arbitrary function of the input voltage.
+
+* `memory-fixed` Reproduce a fixed-length sequence of binary inputs.    
+
+* `memory-variable` Reproduce a variable-length sequence of binary inputs.
+
+* `picture2d` Generate 2D color or grayscale images using Compositional Pattern-Producing Networks.
+
+* `single-pole-balancing` Balance a pole on top of a movable cart.

examples/memory/clean.sh renamed to examples/circuits/clean.sh

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-rm *.csv
+rm *.csv *.svg *.gv

examples/circuits/config

@@ -1,26 +1,26 @@
 [NEAT]
-max_fitness_threshold = -0.05
-pop_size              = 100
+max_fitness_threshold = -0.01
+pop_size              = 350
 reset_on_extinction   = False
 
 [CircuitGenome]
 # component type options
 component_default      = resistor
-component_mutate_rate  = 0.1
+component_mutate_rate  = 0.2
 component_options      = resistor diode
 
 # component value options
 value_init_mean          = 3.0
-value_init_stdev         = 0.1
-value_max_value          = 9.0
+value_init_stdev         = 0.5
+value_max_value          = 6.0
 value_min_value          = 0.0
 value_mutate_power       = 0.5
-value_mutate_rate        = 0.7
+value_mutate_rate        = 0.8
 value_replace_rate       = 0.1
 
 # genome compatibility options
 compatibility_disjoint_coefficient = 1.0
-compatibility_threshold            = 3.0
+compatibility_threshold            = 2.5
 compatibility_weight_coefficient   = 1.0
 
 # connection add/remove rates
@@ -29,19 +29,19 @@ conn_delete_prob        = 0.5
 
 # connection enable options
 enabled_default         = True
-enabled_mutate_rate     = 0.01
+enabled_mutate_rate     = 0.05
 
 # node add/remove rates
 node_add_prob           = 0.2
 node_delete_prob        = 0.2
 
 # network parameters
-num_inputs              = 1
+num_inputs              = 3
 num_outputs             = 1
 
 [DefaultStagnation]
 species_fitness_func = max
-max_stagnation       = 20
+max_stagnation       = 25
 
 [DefaultReproduction]
 elitism            = 2

examples/circuits/evolve.py

@@ -321,7 +321,18 @@ def add_hidden_nodes(self, config):
 
     @classmethod
     def create(cls, config, key):
-        return cls.create_unconnected(config, key)
+        c = cls(key, config)
+
+        # Create node genes for the output pins.
+        for node_key in config.output_keys:
+            c.nodes[node_key] = cls.create_node(config, node_key)
+
+        for input_id in config.input_keys:
+            for node_id in iterkeys(c.nodes):
+                connection = cls.create_connection(config, input_id, node_id)
+                c.connections[connection.key] = connection
+
+        return c
 
     @staticmethod
     def create_node(config, node_id):
@@ -335,17 +346,6 @@ def create_connection(config, input_id, output_id):
         connection.init_attributes(config)
         return connection
 
-    @classmethod
-    def create_unconnected(cls, config, key):
-        '''Create a genome for a network with no hidden nodes and no connections.'''
-        c = cls(key, config)
-
-        # Create node genes for the output pins.
-        for node_key in config.output_keys:
-            c.nodes[node_key] = cls.create_node(config, node_key)
-
-        return c
-
 
 def get_pins(key):
     pins = []
@@ -366,8 +366,10 @@ def create_circuit(genome, config):
     circuit.include(spice_library['1N4148'])
 
     Vbase = circuit.V('base', 'input1', circuit.gnd, 2)
-    circuit.R('test1', 'node0', circuit.gnd, 1e6)
-    circuit.R('test2', 'node0', 'input1', 1e6)
+    Vcc = circuit.V('cc', 'input2', circuit.gnd, 5)
+    Vgnd = circuit.V('gnd', 'input3', circuit.gnd, 0)
+    #circuit.R('test1', 'node0', circuit.gnd, 1e6)
+    #circuit.R('test2', 'node0', 'input1', 1e6)
     ridx = 1
     xidx = 1
     for key, c in iteritems(genome.connections):
@@ -386,7 +388,8 @@ def create_circuit(genome, config):
 V_MAX = 2.0
 
 def get_expected(inputs):
-    return 0.5 * inputs + 0.15 * inputs ** 2
+    #return 0.5 * inputs - 0.15 * inputs ** 2
+    return 2.0 / (1.0 + np.exp(-2.5 * (inputs - 1.0)))
 
 
 def simulate(genome, config):
@@ -402,6 +405,7 @@ def simulate(genome, config):
         expected = get_expected(inputs)
 
         return -np.sum((expected - outputs) ** 2)
+        #return -np.max(np.abs(expected - outputs))
     except Exception as e:
         return -1000
 
@@ -426,7 +430,7 @@ def run(config_file):
     p.add_reporter(stats)
 
     # Run for up to 300 generations.
-    winner = p.run(eval_genomes, 100)
+    winner = p.run(eval_genomes, 1000)
 
     # Display the winning genome.
     print('\nBest genome:\n{!s}'.format(winner))
@@ -448,7 +452,7 @@ def run(config_file):
     plt.gca().set_aspect(1)
     plt.show()
 
-    visualize.plot_stats(stats, ylog=False, view=False)
+    visualize.plot_stats(stats, ylog=True, view=False)
     visualize.plot_species(stats, view=False)
 
 

examples/memory-fixed/README.md

@@ -0,0 +1,3 @@
+## Fixed-length Sequence Memory Evolution ##
+
+`evolve.py` Generates networks to reproduce a fixed-length sequence of binary inputs.

examples/memory-fixed/clean.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+rm *.csv *.svg *.gv

examples/memory-fixed/config

@@ -0,0 +1,61 @@
+# NEAT configuration for the bit-sequence memory experiment.
+
+# The `NEAT` section specifies parameters particular to the NEAT algorithm
+# or the experiment itself.  This is the only required section.
+[NEAT]
+pop_size              = 2000
+max_fitness_threshold = 0.95
+reset_on_extinction   = 0
+
+[DefaultGenome]
+num_inputs              = 2
+num_hidden              = 1
+num_outputs             = 1
+initial_connection      = partial 0.5
+feed_forward            = 0
+compatibility_threshold = 3.0
+compatibility_disjoint_coefficient = 1.0
+compatibility_weight_coefficient   = 0.6
+conn_add_prob           = 0.1
+conn_delete_prob        = 0.1
+node_add_prob           = 0.1
+node_delete_prob        = 0.1
+activation_default      = my_sinc_function
+activation_options      = sigmoid my_sinc_function
+activation_mutate_rate  = 0.1
+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
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+response_init_mean      = 1.0
+response_init_stdev     = 0.1
+response_replace_rate   = 0.1
+response_mutate_rate    = 0.1
+response_mutate_power   = 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
+enabled_default         = True
+enabled_mutate_rate     = 0.01
+
+[DefaultStagnation]
+species_fitness_func = max
+max_stagnation  = 20
+
+[DefaultReproduction]
+elitism            = 2
+survival_threshold = 0.2
+

examples/memory-fixed/evolve.py

@@ -0,0 +1,103 @@
+"""
+This example produces networks that can remember a fixed-length sequence of bits. It is
+intentionally very (overly?) simplistic just to show the usage of the NEAT library. However,
+if you come up with a more interesting or impressive example, please submit a pull request!
+
+This example also demonstrates the use of a custom activation function.
+"""
+
+from __future__ import print_function
+
+import math
+import os
+import random
+
+import neat
+import visualize
+
+# N is the length of the test sequence.
+N = 3
+# num_tests is the number of random examples each network is tested against.
+num_tests = 2 ** N
+
+
+def eval_genomes(genomes, config):
+    for genome_id, genome in genomes:
+        net = neat.nn.RecurrentNetwork.create(genome, config)
+
+        error = 0.0
+        for _ in range(num_tests):
+            # Create a random sequence, and feed it to the network with the
+            # second input set to zero.
+            seq = [random.choice((0.0, 1.0)) for _ in range(N)]
+            net.reset()
+            for s in seq:
+                inputs = [s, 0.0]
+                net.activate(inputs)
+
+            # Set the second input to one, and get the network output.
+            for s in seq:
+                inputs = [0.0, 1.0]
+                output = net.activate(inputs)
+
+                error += (output[0] - s) ** 2
+
+        genome.fitness = 1.0 - 4.0 * (error / (N * num_tests))
+
+
+def run():
+    # Determine path to configuration file.
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, 'config')
+    config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultStagnation, config_path)
+
+    # Demonstration of saving a configuration back to a text file.
+    config.save('test_save_config.txt')
+
+    # Demonstration of how to add your own custom activation function.
+    # This sinc function will be available if my_sinc_function is included in the
+    # config file activation_options option under the DefaultGenome section.
+    # Note that sinc is not necessarily useful for this example, it was chosen
+    # arbitrarily just to demonstrate adding a custom activation function.
+    def sinc(x):
+        return 1.0 if x == 0 else math.sin(x) / x
+
+    config.genome_config.add_activation('my_sinc_function', sinc)
+
+    pop = neat.Population(config)
+    stats = neat.StatisticsReporter()
+    pop.add_reporter(stats)
+    pop.add_reporter(neat.StdOutReporter())
+
+    winner = pop.run(eval_genomes, 1000)
+
+    # Log statistics.
+    stats.save()
+
+    # Show output of the most fit genome against a random input.
+    print('\nBest genome:\n{!s}'.format(winner))
+    print('\nOutput:')
+    winner_net = neat.nn.RecurrentNetwork.create(winner, config)
+    for n in range(num_tests):
+        print('\nRun {0} output:'.format(n))
+        seq = [random.choice((0.0, 1.0)) for _ in range(N)]
+        winner_net.reset()
+        for s in seq:
+            inputs = [s, 0.0]
+            winner_net.activate(inputs)
+            print('\tseq {0}'.format(inputs))
+
+        correct = True
+        for s in seq:
+            output = winner_net.activate([0, 1])
+            print("\texpected {0:1.5f} got {1:1.5f}".format(s, output[0]))
+            correct = correct and round(output[0]) == s
+        print("OK" if correct else "FAIL")
+
+    node_names = {-1: 'I', -2: 'T', 0: 'rI'}
+    visualize.draw_net(config, winner, True, node_names=node_names)
+    visualize.plot_stats(stats, ylog=False, view=True)
+
+
+if __name__ == '__main__':
+    run()