Removed unused code.

Added input check to RecurrentNetwork.activate.
Made FeedForwardNetwork more consistent with RecurrentNetwork.
Added tests for FeedForwardNetwork.
Added to RecurrentNetwork tests.

Author: CodeReclaimers

neat/nn/__init__.py

@@ -3,20 +3,20 @@
 
 
 class FeedForwardNetwork(object):
-    def __init__(self, max_node, inputs, outputs, node_evals):
-        self.node_evals = node_evals
+    def __init__(self, inputs, outputs, node_evals):
         self.input_nodes = inputs
         self.output_nodes = outputs
+        self.node_evals = node_evals
         self.values = dict((key, 0.0) for key in inputs + outputs)
 
-    def serial_activate(self, inputs):
+    def activate(self, inputs):
         if len(self.input_nodes) != len(inputs):
             raise Exception("Expected {0} inputs, got {1}".format(len(self.input_nodes), len(inputs)))
 
         for k, v in zip(self.input_nodes, inputs):
             self.values[k] = v
 
-        for node, agg_func, act_func, bias, response, links in self.node_evals:
+        for node, act_func, agg_func, bias, response, links in self.node_evals:
             #print(node, func, bias, response, links)
             node_inputs = []
             for i, w in links:
@@ -38,7 +38,6 @@ def create_feed_forward_phenotype(genome, config):
     layers = feed_forward_layers(config.genome_config.input_keys, config.genome_config.output_keys, connections)
     #print(layers)
     node_evals = []
-    max_used_node = max(max(config.genome_config.input_keys), max(config.genome_config.output_keys))
     for layer in layers:
         for node in layer:
             inputs = []
@@ -48,17 +47,15 @@ def create_feed_forward_phenotype(genome, config):
                 if cg.output == node and cg.enabled:
                     inputs.append((cg.input, cg.weight))
                     node_expr.append("v[%d] * %f" % (cg.input, cg.weight))
-                    max_used_node = max(max_used_node, cg.input)
 
-            max_used_node = max(max_used_node, node)
             ng = genome.nodes[node]
             aggregation_function = config.genome_config.aggregation_function_defs[ng.aggregation]
             activation_function = config.genome_config.activation_defs.get(ng.activation)
-            node_evals.append((node, aggregation_function, activation_function, ng.bias, ng.response, inputs))
+            node_evals.append((node, activation_function, aggregation_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, config.genome_config.input_keys, config.genome_config.output_keys, node_evals)
+    return FeedForwardNetwork(config.genome_config.input_keys, config.genome_config.output_keys, node_evals)
 
 
 class RecurrentNetwork(object):
@@ -83,6 +80,9 @@ def reset(self):
         self.active = 0
 
     def activate(self, inputs):
+        if len(self.input_nodes) != len(inputs):
+            raise Exception("Expected {0} inputs, got {1}".format(len(self.input_nodes), len(inputs)))
+
         ivalues = self.values[self.active]
         ovalues = self.values[1 - self.active]
         self.active = 1 - self.active

tests/test_feedforward.py renamed to tests/test_feedforward_network.py

@@ -1,11 +1,49 @@
-import random
-from neat import nn
+from neat import activations
+from neat.nn import FeedForwardNetwork
 
 
 def assert_almost_equal(x, y, tol):
     assert abs(x - y) < tol, "{!r} !~= {!r}".format(x, y)
 
 
+def test_unconnected():
+    # Unconnected network with no inputs and one output neuron.
+    node_evals = [(0, activations.sigmoid_activation, sum, 0.0, 1.0, [])]
+    r = FeedForwardNetwork([], [0], node_evals)
+
+    assert r.values[0] == 0.0
+
+    result = r.activate([])
+
+    assert_almost_equal(r.values[0], 0.5, 0.001)
+    assert result[0] == r.values[0]
+
+    result = r.activate([])
+
+    assert_almost_equal(r.values[0], 0.5, 0.001)
+    assert result[0] == r.values[0]
+
+
+def test_basic():
+    # Very simple network with one connection of weight one to a single sigmoid output node.
+    node_evals = [(0, activations.sigmoid_activation, sum, 0.0, 1.0, [(-1, 1.0)])]
+    r = FeedForwardNetwork([-1], [0], node_evals)
+
+    assert r.values[0] == 0.0
+
+    result = r.activate([1.0])
+
+    assert r.values[-1] == 1.0
+    assert_almost_equal(r.values[0], 0.731, 0.001)
+    assert result[0] == r.values[0]
+
+    result = r.activate([2.0])
+
+    assert r.values[-1] == 2.0
+    assert_almost_equal(r.values[0], 0.881, 0.001)
+    assert result[0] == r.values[0]
+
+
 # TODO: Update this test for the current implementation.
 # def test_simple_nohidden():
 #     config_params = {
@@ -72,10 +110,5 @@ def assert_almost_equal(x, y, tol):
 
 
 if __name__ == '__main__':
-    test_creates_cycle()
-    test_required_for_output()
-    test_fuzz_required()
-    test_feed_forward_layers()
-    test_fuzz_feed_forward_layers()
-    #test_simple_nohidden()
-    #test_simple_hidden()
+    test_unconnected()
+    test_basic()

tests/test_recurrent_network.py

@@ -1,4 +1,5 @@
-from neat import activations, nn
+from neat import activations
+from neat.nn import RecurrentNetwork
 
 
 def assert_almost_equal(x, y, tol):
@@ -8,45 +9,49 @@ def assert_almost_equal(x, y, tol):
 def test_unconnected():
     # Unconnected network with no inputs and one output neuron.
     node_evals = [(0, activations.sigmoid_activation, sum, 0.0, 1.0, [])]
-    r = nn.RecurrentNetwork([], [0], node_evals)
+    r = RecurrentNetwork([], [0], node_evals)
 
     assert r.active == 0
     assert len(r.values) == 2
     assert len(r.values[0]) == 1
     assert len(r.values[1]) == 1
 
-    r.activate([1.0])
+    result = r.activate([])
 
     assert r.active == 1
     assert_almost_equal(r.values[1][0], 0.5, 0.001)
+    assert result[0] == r.values[1][0]
 
-    r.activate([2.0])
+    result = r.activate([])
 
     assert r.active == 0
     assert_almost_equal(r.values[0][0], 0.5, 0.001)
+    assert result[0] == r.values[0][0]
 
 
 def test_basic():
     # Very simple network with one connection of weight one to a single sigmoid output node.
     node_evals = [(0, activations.sigmoid_activation, sum, 0.0, 1.0, [(-1, 1.0)])]
-    r = nn.RecurrentNetwork([-1], [0], node_evals)
+    r = RecurrentNetwork([-1], [0], node_evals)
 
     assert r.active == 0
     assert len(r.values) == 2
     assert len(r.values[0]) == 2
     assert len(r.values[1]) == 2
 
-    r.activate([1.0])
+    result = r.activate([1.0])
 
     assert r.active == 1
     assert r.values[1][-1] == 1.0
     assert_almost_equal(r.values[1][0], 0.731, 0.001)
+    assert result[0] == r.values[1][0]
 
-    r.activate([2.0])
+    result = r.activate([2.0])
 
     assert r.active == 0
     assert r.values[0][-1] == 2.0
     assert_almost_equal(r.values[0][0], 0.881, 0.001)
+    assert result[0] == r.values[0][0]
 
 
 if __name__ == '__main__':