evonet 0.1.0.dev25__tar.gz → 0.1.0.dev27__tar.gz

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

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

evonet-0.1.0.dev27/evonet/connection.py

@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: MIT
+"""
+Connection between neurons in an evolvable neural network.
+
+A connection links a source neuron to a target neuron and transmits a weighted signal.
+Supports optional connection types for specialized behaviors (e.g. inhibitory,
+recurrent).
+"""
+
+
+from collections import deque
+from typing import TYPE_CHECKING, Deque, Optional
+
+from evonet.enums import ConnectionType
+
+if TYPE_CHECKING:
+    from evonet.neuron import Neuron
+
+
+class Connection:
+    """
+    Represents a directed, weighted connection between two neurons.
+
+    Attributes:
+        source (Neuron): The source neuron (presynaptic).
+        target (Neuron): The target neuron (postsynaptic).
+        weight (float): Multiplicative weight of the transmitted signal.
+        delay (int): Delay in discrete time steps (used for recurrent edges).
+        type (ConnectionType): Type of connection (e.g. standard, recurrent).
+    """
+
+    def __init__(
+        self,
+        source: "Neuron",
+        target: "Neuron",
+        weight: float = 1.0,
+        delay: int = 0,
+        conn_type: ConnectionType = ConnectionType.STANDARD,
+    ) -> None:
+
+        if delay < 0:
+            raise ValueError("delay must be >= 0")
+
+        # Normalize: recurrent implies delay >= 1
+        if conn_type is ConnectionType.RECURRENT and delay == 0:
+            delay = 1
+
+        self.source = source
+        self.target = target
+        self.weight = weight
+        self.delay = delay
+        self.type = conn_type
+
+        self._history: Optional[Deque[float]] = None
+        if self.type is ConnectionType.RECURRENT:
+            self._history = deque(maxlen=self.delay)
+
+    def set_delay(self, delay: int) -> None:
+        if self.type is not ConnectionType.RECURRENT:
+            raise ValueError("set_delay is only valid for recurrent connections")
+        if delay <= 0:
+            delay = 1
+        self.delay = int(delay)
+        self._history = deque(maxlen=self.delay)
+
+    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.
+
+        Returns:
+            float: source.output × weight
+        """
+
+        return self.source.output * self.weight
+
+    def __repr__(self) -> str:
+        """
+        Return a concise string representation of the connection.
+
+        Example:
+            <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.dev27}/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,15 @@ class Nnet:
         if weight is None:
             weight = 0.0
 
-        conn = Connection(source, target, weight=weight, conn_type=conn_type)
+        # Normalize recurrent delays
+        if conn_type is ConnectionType.RECURRENT and delay <= 0:
+            delay = 1
+        if conn_type is not ConnectionType.RECURRENT and delay < 0:
+            delay = 0
+
+        conn = Connection(
+            source, target, weight=weight, conn_type=conn_type, delay=delay
+        )
         source.outgoing.append(conn)
         target.incoming.append(conn)
 
@@ -361,6 +371,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 +408,7 @@ 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
+                        n.input += c.weight * c.delayed_source_output()
 
         # Feed-forward by layers: activate first, then propagate non-recurrent edges
         for layer in self.layers:
@@ -426,6 +441,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:
+                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.dev27}/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.dev27}/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.dev27}/evonet.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0.dev25
+Version: 0.1.0.dev27
 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.dev27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evonet"
-version = "0.1.0.dev25"
+version = "0.1.0.dev27"
 description = "Evolvable neural network core for integration with EvoLib"
 authors = [
     { name = "EvoLib", email = "evolib@dismail.de" }
@@ -48,7 +48,7 @@ include = ["evonet*"]
 # Tool-Konfigurationen
 [tool.black]
 line-length = 88
-target-version = ["py311"]
+target-version = ["py312"]
 
 [tool.isort]
 profile = "black"

{evonet-0.1.0.dev25 → evonet-0.1.0.dev27}/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,88 @@ 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)
+
+
+def test_recurrent_delay_zero_normalizes_to_one() -> None:
+    net, n_in, n_hid, _ = _mk_linear_ih_h_o()
+    c = net.add_connection(
+        n_hid, n_hid, weight=1.0, conn_type=ConnectionType.RECURRENT, delay=0
+    )
+    assert c is not None
+    assert c.delay == 1

evonet-0.1.0.dev25/evonet/connection.py

@@ -1,70 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""
-Connection between neurons in an evolvable neural network.
-
-A connection links a source neuron to a target neuron and transmits a weighted signal.
-Supports optional connection types for specialized behaviors (e.g. inhibitory,
-recurrent).
-"""
-
-
-from typing import TYPE_CHECKING
-
-from evonet.enums import ConnectionType
-
-if TYPE_CHECKING:
-    from evonet.neuron import Neuron
-
-
-class Connection:
-    """
-    Represents a directed, weighted connection between two neurons.
-
-    Attributes:
-        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).
-    """
-
-    def __init__(
-        self,
-        source: "Neuron",
-        target: "Neuron",
-        weight: float = 1.0,
-        delay: int = 0,
-        conn_type: ConnectionType = ConnectionType.STANDARD,
-    ) -> None:
-
-        self.source = source
-        self.target = target
-        self.weight = weight
-        self.delay = delay
-        self.type: ConnectionType = conn_type
-
-    def get_signal(self) -> float:
-        """
-        Return the weighted signal from the source neuron.
-
-        Returns:
-            float: source.output × weight
-        """
-
-        return self.source.output * self.weight
-
-    def __repr__(self) -> str:
-        """
-        Return a concise string representation of the connection.
-
-        Example:
-            <Conn abc123 -> def456 w=0.85 type=standard>
-        """
-
-        type_str = self.type.name.lower()
-        return (
-            f"<Conn {self.source.id[:6]} "
-            f"-> {self.target.id[:6]} "
-            f"w={self.weight:.2f} type={type_str}>"
-        )