Fix orphaned nodes bug.

Author: CodeReclaimers

neat/aggregations.py

@@ -20,23 +20,28 @@ def sum_aggregation(x):
 
 
 def max_aggregation(x):
-    return max(x)
+    # Handle empty input (for orphaned nodes with no incoming connections)
+    return max(x) if x else 0.0
 
 
 def min_aggregation(x):
-    return min(x)
+    # Handle empty input (for orphaned nodes with no incoming connections)
+    return min(x) if x else 0.0
 
 
 def maxabs_aggregation(x):
-    return max(x, key=abs)
+    # Handle empty input (for orphaned nodes with no incoming connections)
+    return max(x, key=abs) if x else 0.0
 
 
 def median_aggregation(x):
-    return median2(x)
+    # Handle empty input (for orphaned nodes with no incoming connections)
+    return median2(x) if x else 0.0
 
 
 def mean_aggregation(x):
-    return mean(x)
+    # Handle empty input (for orphaned nodes with no incoming connections)
+    return mean(x) if x else 0.0
 
 
 class InvalidAggregationFunction(TypeError):

neat/graphs.py

@@ -38,30 +38,14 @@ def required_for_output(inputs, outputs, connections):
     """
     assert not set(inputs).intersection(outputs)
 
-    # Create a graph representation of the connections
-    graph = defaultdict(list)
-    reverse_graph = defaultdict(list)
-    for a, b in connections:
-        graph[a].append(b)
-        reverse_graph[b].append(a)
-
-    # Perform a breadth-first search (BFS) from each input to find all reachable nodes
-    reachable = set(inputs)
-    queue = deque(inputs)
-
-    while queue:
-        node = queue.popleft()
-        for neighbor in graph[node]:
-            if neighbor not in reachable:
-                reachable.add(neighbor)
-                queue.append(neighbor)
-
-    # Now, traverse from the outputs and find all nodes that are required to reach the outputs
+    # Traverse backwards from outputs to find all nodes that feed into outputs.
+    # This includes orphaned nodes (nodes with no incoming connections) that
+    # connect to outputs, as they are required to compute the output.
     required = set(outputs)
     s = set(outputs)
     while True:
-        # Find nodes not in s whose output is consumed by a node in s and is reachable from inputs
-        t = set(a for (a, b) in connections if b in s and a not in s and a in reachable)
+        # Find nodes not in s whose output is consumed by a node in s
+        t = set(a for (a, b) in connections if b in s and a not in s)
 
         if not t:
             break
@@ -90,8 +74,23 @@ def feed_forward_layers(inputs, outputs, connections):
 
     required = required_for_output(inputs, outputs, connections)
 
+    # Find required nodes that have no incoming connections.
+    # These are "bias neurons" that output activation(bias) independent of inputs.
+    nodes_with_inputs = set()
+    for a, b in connections:
+        nodes_with_inputs.add(b)
+
+    # Bias neurons are required nodes with no incoming connections
+    bias_neurons = required - nodes_with_inputs
+
     layers = []
-    potential_input = set(inputs)
+    # Start with inputs AND bias neurons in the ready set
+    potential_input = set(inputs) | bias_neurons
+
+    # If there are bias neurons, add them as the first layer
+    if bias_neurons:
+        layers.append(bias_neurons.copy())
+
     while True:
         # Find candidate nodes c for the next layer.  These nodes should connect
         # a node in s to a node not in s.

tests/test_graphs.py

@@ -152,9 +152,85 @@ def test_fuzz_feed_forward_layers():
         feed_forward_layers(inputs, outputs, connections)
 
 
+def test_orphaned_single_node():
+    """Test a single orphaned hidden node that connects to output."""
+    inputs = [0, 1]
+    outputs = [3]
+    # Node 2 has no incoming connections (orphaned) but connects to output 3
+    connections = [(2, 3)]
+    layers, required = feed_forward_layers(inputs, outputs, connections)
+    # Node 2 should appear in the first layer as a bias neuron
+    # Node 3 should appear in the second layer
+    assert [{2}, {3}] == layers
+    assert {2, 3} == required
+
+
+def test_orphaned_multiple_nodes():
+    """Test multiple orphaned nodes in the same network."""
+    inputs = [0]
+    outputs = [4]
+    # Nodes 2 and 3 are both orphaned (no incoming connections)
+    # Both connect to output node 4
+    connections = [(2, 4), (3, 4)]
+    layers, required = feed_forward_layers(inputs, outputs, connections)
+    # Both orphaned nodes should appear in the first layer
+    # Output node 4 should appear in the second layer
+    assert [{2, 3}, {4}] == layers
+    assert {2, 3, 4} == required
+
+
+def test_orphaned_mixed():
+    """Test a mix of normal nodes and orphaned nodes."""
+    inputs = [0, 1]
+    outputs = [5]
+    # Node 2 gets input from 0 (normal)
+    # Node 3 is orphaned (no inputs)
+    # Node 4 gets inputs from both 2 and 3
+    # Node 5 (output) gets input from 4
+    connections = [(0, 2), (2, 4), (3, 4), (4, 5)]
+    layers, required = feed_forward_layers(inputs, outputs, connections)
+    # First layer: orphaned node 3
+    # Second layer: node 2 (has input from 0)
+    # Third layer: node 4 (has inputs from 2 and 3)
+    # Fourth layer: node 5 (has input from 4)
+    assert [{3}, {2}, {4}, {5}] == layers
+    assert {2, 3, 4, 5} == required
+
+
+def test_orphaned_output_node():
+    """Test an output node with no incoming connections."""
+    inputs = [0, 1]
+    outputs = [2, 3]
+    # Output node 2 has a connection from input 0
+    # Output node 3 has no connections at all (orphaned output)
+    connections = [(0, 2)]
+    layers, required = feed_forward_layers(inputs, outputs, connections)
+    # First layer: orphaned output node 3
+    # Second layer: normal output node 2
+    assert [{3}, {2}] == layers
+    assert {2, 3} == required
+
+
+def test_orphaned_with_self_loop_prevention():
+    """Test orphaned nodes don't interfere with cycle detection."""
+    inputs = [0]
+    outputs = [3]
+    # Node 2 is orphaned and connects to output 3
+    connections = [(2, 3)]
+    layers, required = feed_forward_layers(inputs, outputs, connections)
+    assert [{2}, {3}] == layers
+    # Verify that adding a self-loop would still be detected as a cycle
+    assert creates_cycle(connections, (2, 2))
+
+
 if __name__ == '__main__':
     test_creates_cycle()
     test_required_for_output()
     test_fuzz_required()
     test_feed_forward_layers()
     test_fuzz_feed_forward_layers()
+    test_orphaned_single_node()
+    test_orphaned_multiple_nodes()
+    test_orphaned_mixed()
+    test_orphaned_output_node()
+    test_orphaned_with_self_loop_prevention()

tests/test_graphs_edge_cases.py

@@ -202,12 +202,13 @@ def test_partially_connected_outputs(self):
         outputs = [5, 6]
         connections = [
             (0, 2), (2, 5),  # Path to output 5
-            (3, 6)           # Output 6 not connected to inputs
+            (3, 6)           # Output 6 connected via orphaned node 3
         ]
 
         required = required_for_output(inputs, outputs, connections)
-        # Only output 5 and its dependencies
-        self.assertEqual(required, {2, 5, 6})  # 6 is in outputs so included
+        # Node 3 is required even though it's orphaned (not reachable from inputs)
+        # because it feeds into output 6. It acts as a "bias neuron".
+        self.assertEqual(required, {2, 3, 5, 6})
 
     def test_recurrent_connections(self):
         """Test with recurrent (cyclic) connections."""
@@ -424,8 +425,8 @@ def test_empty_network(self):
         connections = []
 
         layers, required = feed_forward_layers(inputs, outputs, connections)
-        # No layers if no connections
-        self.assertEqual(layers, [])
+        # Output node 2 is orphaned (no incoming connections), so it appears as first layer
+        self.assertEqual(layers, [{2}])
         self.assertEqual(required, {2})
 
     def test_bottleneck_structure(self):

tests/test_issue_188.py

@@ -0,0 +1,110 @@
+"""
+Tests for GitHub issue #188: Class attribute bug in neat.attributes
+
+This tests that _config_items is properly isolated between instances
+rather than being shared at the class level.
+"""
+
+import unittest
+from neat.attributes import StringAttribute, FloatAttribute, BoolAttribute, IntegerAttribute
+
+
+class TestIssue188AttributeIsolation(unittest.TestCase):
+    """Test that attribute instances don't share _config_items."""
+
+    def test_string_attribute_isolation(self):
+        """Test that StringAttribute instances have separate _config_items."""
+        attr1 = StringAttribute('activation', options='sigmoid')
+        attr2 = StringAttribute('aggregation', options='sum')
+
+        # Should NOT share the same object
+        self.assertIsNot(attr1._config_items, attr2._config_items,
+                        "StringAttribute instances should not share _config_items")
+
+        # Should have different option values
+        self.assertEqual(attr1._config_items['options'][1], 'sigmoid')
+        self.assertEqual(attr2._config_items['options'][1], 'sum')
+
+    def test_string_attribute_mutation_isolation(self):
+        """Test that modifying one instance doesn't affect another."""
+        attr1 = StringAttribute('foo', options='option_a')
+        attr2 = StringAttribute('bar', options='option_b')
+
+        # Modify attr1's _config_items
+        attr1._config_items['options'] = ['MODIFIED', 'TEST']
+
+        # attr2 should NOT be affected
+        self.assertEqual(attr2._config_items['options'][1], 'option_b',
+                        "Modifying attr1 should not affect attr2")
+
+    def test_float_attribute_isolation(self):
+        """Test that FloatAttribute instances have separate _config_items."""
+        attr1 = FloatAttribute('weight', init_mean=0.0)
+        attr2 = FloatAttribute('bias', init_mean=1.0)
+
+        self.assertIsNot(attr1._config_items, attr2._config_items)
+        self.assertEqual(attr1._config_items['init_mean'][1], 0.0)
+        self.assertEqual(attr2._config_items['init_mean'][1], 1.0)
+
+    def test_bool_attribute_isolation(self):
+        """Test that BoolAttribute instances have separate _config_items."""
+        attr1 = BoolAttribute('enabled', default='True')
+        attr2 = BoolAttribute('flag', default='False')
+
+        self.assertIsNot(attr1._config_items, attr2._config_items)
+        self.assertEqual(attr1._config_items['default'][1], 'True')
+        self.assertEqual(attr2._config_items['default'][1], 'False')
+
+    def test_integer_attribute_isolation(self):
+        """Test that IntegerAttribute instances have separate _config_items."""
+        attr1 = IntegerAttribute('count', min_value=0)
+        attr2 = IntegerAttribute('index', min_value=1)
+
+        self.assertIsNot(attr1._config_items, attr2._config_items)
+        self.assertEqual(attr1._config_items['min_value'][1], 0)
+        self.assertEqual(attr2._config_items['min_value'][1], 1)
+
+    def test_mixed_attribute_types_isolation(self):
+        """Test that different attribute types don't interfere with each other."""
+        float_attr = FloatAttribute('weight')
+        string_attr = StringAttribute('activation')
+        bool_attr = BoolAttribute('enabled')
+        int_attr = IntegerAttribute('count')
+
+        # Each should have its own _config_items
+        items_list = [
+            float_attr._config_items,
+            string_attr._config_items,
+            bool_attr._config_items,
+            int_attr._config_items
+        ]
+
+        # All should be different objects
+        for i, items_i in enumerate(items_list):
+            for j, items_j in enumerate(items_list):
+                if i != j:
+                    self.assertIsNot(items_i, items_j,
+                                   f"Attribute instances {i} and {j} should not share _config_items")
+
+    def test_genes_pattern(self):
+        """Test the actual usage pattern from DefaultNodeGene."""
+        # This is how it's used in genes.py
+        attr_activation = StringAttribute('activation', options='')
+        attr_aggregation = StringAttribute('aggregation', options='')
+
+        # Should have separate _config_items even with same default value
+        self.assertIsNot(attr_activation._config_items, attr_aggregation._config_items,
+                        "activation and aggregation attributes should have separate _config_items")
+
+        # Both should have empty string as options default
+        self.assertEqual(attr_activation._config_items['options'][1], '')
+        self.assertEqual(attr_aggregation._config_items['options'][1], '')
+
+        # Modifying one should not affect the other
+        attr_activation._config_items['options'][1] = 'modified'
+        self.assertEqual(attr_aggregation._config_items['options'][1], '',
+                        "Modifying activation should not affect aggregation")
+
+
+if __name__ == '__main__':
+    unittest.main()