evonet 0.1.0.dev25__tar.gz → 0.1.0.dev26__tar.gz

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0.dev25
+Version: 0.1.0.dev26
 Summary: Evolvable neural network core for integration with EvoLib
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/evonet/connection.py

@@ -8,7 +8,8 @@ recurrent).
 """
 
 
-from typing import TYPE_CHECKING
+from collections import deque
+from typing import TYPE_CHECKING, Deque, Optional
 
 from evonet.enums import ConnectionType
 
@@ -24,9 +25,8 @@ class Connection:
         source (Neuron): The source neuron (presynaptic).
         target (Neuron): The target neuron (postsynaptic).
         weight (float): Multiplicative weight of the transmitted signal.
-        delay (int): Optional delay in time steps (not yet implemented).
-        type (ConnectionType): Type of connection (e.g. standard, recurrent,
-                               inhibitory).
+        delay (int): Delay in discrete time steps (used for recurrent edges).
+        type (ConnectionType): Type of connection (e.g. standard, recurrent).
     """
 
     def __init__(
@@ -44,6 +44,47 @@ class Connection:
         self.delay = delay
         self.type: ConnectionType = conn_type
 
+        self._history: Optional[Deque[float]] = None
+        if self.delay > 0:
+            self._history = deque(maxlen=self.delay)
+
+        if self.delay < 0:
+            raise ValueError("delay must be >= 0")
+
+    def push_source_output(self, value: float) -> None:
+        """
+        Push the current source output into the delay buffer.
+
+        This should be called once per time step after the network computed outputs.
+        """
+        if self._history is None:
+            return
+        self._history.append(float(value))
+
+    def delayed_source_output(self) -> float:
+        """
+        Return the delayed source output.
+
+        Semantics:
+            - delay == 0  -> no delay buffer used (caller decides what to do)
+            - delay > 0   -> returns output[t-delay] if available else 0.0
+        """
+        if self.delay == 0:
+            return 0.0
+
+        if self._history is None:
+            return 0.0
+
+        if len(self._history) < self.delay:
+            return 0.0
+
+        return float(self._history[0])
+
+    def reset_buffer(self) -> None:
+        """Clear the internal delay history buffer."""
+        if self._history is not None:
+            self._history.clear()
+
     def get_signal(self) -> float:
         """
         Return the weighted signal from the source neuron.
@@ -59,12 +100,13 @@ class Connection:
         Return a concise string representation of the connection.
 
         Example:
-            <Conn abc123 -> def456 w=0.85 type=standard>
+            <Conn abc123 -> def456 w=0.85 d=3 type=standard>
         """
 
         type_str = self.type.name.lower()
         return (
             f"<Conn {self.source.id[:6]} "
             f"-> {self.target.id[:6]} "
+            f"d={self.delay} "
             f"w={self.weight:.2f} type={type_str}>"
         )

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/evonet/core.py

@@ -318,7 +318,7 @@ class Nnet:
             # --------------------------------------------------------------
             # Create connections
             # --------------------------------------------------------------
-            for src, dst, ctype in forced + sampled:
+            for src, dst, ctype in sampled:
                 self.add_connection(src, dst, weight=weight, conn_type=ctype)
 
         return new_neurons
@@ -329,6 +329,7 @@ class Nnet:
         target: Neuron,
         weight: float | None = None,
         conn_type: ConnectionType = ConnectionType.STANDARD,
+        delay: int = 0,
     ) -> Connection | None:
         """
         Create a directed connection between two neurons.
@@ -338,6 +339,7 @@ class Nnet:
             target (Neuron): Target neuron.
             weight (float | None): Initial weight. If None, 0.0 is used.
             conn_type (ConnectionType): Type of connection (e.g. standard, recurrent).
+            delay (int): Delay in discrete time steps.
 
         Returns:
             Connection: Added Connection.
@@ -349,7 +351,9 @@ class Nnet:
         if weight is None:
             weight = 0.0
 
-        conn = Connection(source, target, weight=weight, conn_type=conn_type)
+        conn = Connection(
+            source, target, weight=weight, conn_type=conn_type, delay=delay
+        )
         source.outgoing.append(conn)
         target.incoming.append(conn)
 
@@ -361,6 +365,11 @@ class Nnet:
             for neuron in layer.neurons:
                 neuron.reset(full=full)
 
+        if full:
+            # Clear delayed history buffers on connections.
+            for conn in self.get_all_connections():
+                conn.reset_buffer()
+
     def calc(self, input_values: list[float]) -> list[float]:
         """
         Perform a forward pass through the network.
@@ -393,7 +402,12 @@ class Nnet:
             for n in layer.neurons:
                 for c in n.incoming:
                     if c.type is ConnectionType.RECURRENT:
-                        c.target.input += c.weight * c.source.last_output
+                        if c.delay > 0:
+                            # Use delayed history if configured
+                            n.input += c.weight * c.delayed_source_output()
+                        else:
+                            # default: 1-step recurrence via last_output
+                            n.input += c.weight * c.source.last_output
 
         # Feed-forward by layers: activate first, then propagate non-recurrent edges
         for layer in self.layers:
@@ -426,6 +440,11 @@ class Nnet:
                     if c.type is not ConnectionType.RECURRENT:
                         c.target.input += c.weight * n.output
 
+        # Update recurrent delay buffers once per time step.
+        for c in self.get_all_connections():
+            if c.type is ConnectionType.RECURRENT and c.delay > 0:
+                c.push_source_output(c.source.output)
+
         return [n.output for n in self.layers[-1].neurons]
 
     def get_all_neurons(self) -> list[Neuron]:

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/evonet/mutation.py

@@ -300,6 +300,9 @@ def add_random_neuron(
     if len(net.layers) == 2:
         net.insert_layer(1)
 
+    if dynamics_params is None:
+        dynamics_params = {}
+
     # Choose target layer (not input, not output)
     candidate_layers = net.layers[1:-1]
     if not candidate_layers:

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/evonet/serialization.py

@@ -49,12 +49,15 @@ def to_dict(net: Nnet) -> dict[str, Any]:
                         "bias": n.bias,
                         "role": n.role.name,
                         "label": n.label,
+                        "dynamics_name": n.dynamics_name,
+                        "dynamics_params": n.dynamics_params,
                         "incoming": [
                             {
                                 "source": c.source.id,
                                 "target": c.target.id,
                                 "weight": c.weight,
                                 "type": c.type.name,  # store enum as string
+                                "delay": c.delay,
                             }
                             for c in n.incoming
                         ],
@@ -81,6 +84,8 @@ def from_dict(data: dict[str, Any]) -> Nnet:
                 bias=n_info["bias"],
                 role=NeuronRole[n_info["role"]],
                 label=n_info.get("label", ""),
+                dynamics_name=n_info.get("dynamics_name", "standard"),
+                dynamics_params=n_info.get("dynamics_params", {}),
                 connection_init="none",
             )[0]
             n.id = n_info["id"]
@@ -92,11 +97,15 @@ def from_dict(data: dict[str, Any]) -> Nnet:
             for c_info in n_info["incoming"]:
                 src = neuron_map[c_info["source"]]
                 dst = neuron_map[c_info["target"]]
+                delay = int(c_info.get("delay", 0))
+                conn_type = ConnectionType[c_info["type"]]
+
                 net.add_connection(
                     src,
                     dst,
                     weight=c_info["weight"],
-                    conn_type=ConnectionType[c_info["type"]],
+                    conn_type=conn_type,
+                    delay=delay,
                 )
 
     return net

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/evonet.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0.dev25
+Version: 0.1.0.dev26
 Summary: Evolvable neural network core for integration with EvoLib
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evonet"
-version = "0.1.0.dev25"
+version = "0.1.0.dev26"
 description = "Evolvable neural network core for integration with EvoLib"
 authors = [
     { name = "EvoLib", email = "evolib@dismail.de" }

{evonet-0.1.0.dev25 → evonet-0.1.0.dev26}/tests/test_recurrent_dynamics.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 from evonet.core import Nnet
 from evonet.enums import ConnectionType, NeuronRole
@@ -104,3 +105,79 @@ def test_recurrent_back_edge_output_to_hidden_linear() -> None:
         actual_outputs.append(y)
 
     assert np.allclose(actual_outputs, expected_outputs, atol=1e-12)
+
+
+def test_recurrent_delay_two_steps_linear_chain() -> None:
+    """
+    A minimal sequence test for recurrent delay buffers.
+
+    Network:
+        input -> hidden -> output
+        hidden has a recurrent self-loop with delay=2
+
+    Expected behaviour (linear activations, weights=1):
+        t0 input=1 -> hidden=1, output=1
+        t1 input=0 -> hidden=0, output=0   (delay=2 not yet filled)
+        t2 input=0 -> hidden=1, output=1   (uses hidden output from t0)
+    """
+    net = Nnet()
+    net.add_layer()  # 0 input
+    net.add_layer()  # 1 hidden
+    net.add_layer()  # 2 output
+
+    n_in = net.add_neuron(
+        layer_idx=0, activation="linear", role=NeuronRole.INPUT, connection_init="none"
+    )[0]
+    n_h = net.add_neuron(
+        layer_idx=1, activation="linear", role=NeuronRole.HIDDEN, connection_init="none"
+    )[0]
+    n_out = net.add_neuron(
+        layer_idx=2, activation="linear", role=NeuronRole.OUTPUT, connection_init="none"
+    )[0]
+
+    net.add_connection(n_in, n_h, weight=1.0, conn_type=ConnectionType.STANDARD)
+    net.add_connection(n_h, n_out, weight=1.0, conn_type=ConnectionType.STANDARD)
+
+    # Recurrent self-loop with delay=2
+    net.add_connection(
+        n_h, n_h, weight=1.0, conn_type=ConnectionType.RECURRENT, delay=2
+    )
+
+    y0 = net.calc([1.0])[0]
+    y1 = net.calc([0.0])[0]
+    y2 = net.calc([0.0])[0]
+
+    assert y0 == pytest.approx(1.0)
+    assert y1 == pytest.approx(0.0)
+    assert y2 == pytest.approx(1.0)
+
+
+def test_reset_full_clears_delay_history() -> None:
+    """Full reset must clear delay buffers, otherwise episodes leak memory."""
+    net = Nnet()
+    net.add_layer()
+    net.add_layer()
+    net.add_layer()
+
+    n_in = net.add_neuron(
+        layer_idx=0, activation="linear", role=NeuronRole.INPUT, connection_init="none"
+    )[0]
+    n_h = net.add_neuron(
+        layer_idx=1, activation="linear", role=NeuronRole.HIDDEN, connection_init="none"
+    )[0]
+    n_out = net.add_neuron(
+        layer_idx=2, activation="linear", role=NeuronRole.OUTPUT, connection_init="none"
+    )[0]
+
+    net.add_connection(n_in, n_h, weight=1.0, conn_type=ConnectionType.STANDARD)
+    net.add_connection(n_h, n_out, weight=1.0, conn_type=ConnectionType.STANDARD)
+    net.add_connection(
+        n_h, n_h, weight=1.0, conn_type=ConnectionType.RECURRENT, delay=2
+    )
+
+    _ = net.calc([1.0])[0]  # fills history partially
+    net.reset(full=True)
+
+    # After full reset, history is gone -> delay contribution must be 0.0
+    y = net.calc([0.0])[0]
+    assert y == pytest.approx(0.0)