evonet 0.1.0.dev4__tar.gz → 0.1.0.dev6__tar.gz

{evonet-0.1.0.dev4 → evonet-0.1.0.dev6}/PKG-INFO

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

{evonet-0.1.0.dev4 → evonet-0.1.0.dev6}/evonet/core.py

@@ -9,11 +9,13 @@ export interfaces.
 
 from __future__ import annotations
 
+from typing import Optional
+
 import graphviz
 import numpy as np
 
 from evonet.connection import Connection
-from evonet.enums import ConnectionType, NeuronRole
+from evonet.enums import ConnectionType, NeuronRole, RecurrentKind
 from evonet.layer import Layer
 from evonet.neuron import Neuron
 
@@ -99,24 +101,23 @@ class Nnet:
         role: NeuronRole = NeuronRole.HIDDEN,
         count: int = 1,
         connect_layer: bool = True,
-    ) -> Neuron:
+        recurrent: Optional[set[RecurrentKind]] = None,
+    ) -> list[Neuron]:
         """
-        Add one or more neurons to a specified layer.
+        Add one or more neurons to the network.
 
         Args:
-            layer_idx (int | None): Index of the target layer. If None, uses last layer.
+            layer_idx (int | None): Target layer index. Defaults to last layer.
             activation (str): Activation function name.
             bias (float): Initial bias value.
-            label (str): Optional label for visualization/debugging.
+            label (str): Optional label.
             role (NeuronRole): Role of the neuron (INPUT, HIDDEN, OUTPUT).
-            count (int): Number of neurons to add.
-            connect_layer (bool): Whether to auto-connect to adjacent layers.
+            count (int): Number of neurons to add (default: 1).
+            connect_layer (bool): If True, auto-connect to adjacent layers.
+            recurrent (set[RecurrentKind] | None): Optional recurrent connection types.
 
         Returns:
-            Neuron: Reference to the last added neuron.
-
-        Raises:
-            ValueError: If layer index is invalid.
+            list[Neuron]: List of added neurons.
         """
 
         if layer_idx is None:
@@ -127,31 +128,67 @@ class Nnet:
         if layer_idx >= len(self.layers):
             raise ValueError(f"Layer index out of bounds: {layer_idx}")
 
-        for _ in range(count):
+        target_layer = self.layers[layer_idx]
+        new_neurons: list[Neuron] = []
+
+        # Create neurons without connections
+        for i in range(count):
             neuron = Neuron(activation=activation, bias=bias)
             neuron.role = role
             neuron.label = label
-
-            self.layers[layer_idx].neurons.append(neuron)
-
-            if connect_layer and layer_idx > 0:
-                # Finde letzten nicht-leeren Layer vor diesem
-                for prev_idx in range(layer_idx - 1, -1, -1):
-                    prev_layer = self.layers[prev_idx]
-                    if prev_layer.neurons:
-                        for prev_neuron in prev_layer.neurons:
-                            self.add_connection(prev_neuron, neuron)
-                        break
-
-            # connect to next non-empty layer
-            if connect_layer and role == NeuronRole.HIDDEN:
-                for next_idx in range(layer_idx + 1, len(self.layers)):
-                    next_layer = self.layers[next_idx]
-                    if next_layer.neurons:
-                        for next_neuron in next_layer.neurons:
-                            self.add_connection(neuron, next_neuron)
-                        break
-        return neuron
+            target_layer.neurons.append(neuron)
+            new_neurons.append(neuron)
+
+        # Connect to previous layer (feedforward)
+        if connect_layer and layer_idx > 0:
+            for prev_neuron in self.layers[layer_idx - 1].neurons:
+                for n in new_neurons:
+                    self.add_connection(prev_neuron, n)
+
+        # Connect to next layer (feedforward)
+        if (
+            connect_layer
+            and role == NeuronRole.HIDDEN
+            and layer_idx < len(self.layers) - 1
+        ):
+
+            for next_neuron in self.layers[layer_idx + 1].neurons:
+                for n in new_neurons:
+                    self.add_connection(n, next_neuron)
+
+        # Recurrent connections
+        if recurrent:
+            if RecurrentKind.DIRECT in recurrent:
+                for n in new_neurons:
+                    if n.role == NeuronRole.HIDDEN:
+                        self.add_connection(n, n, conn_type=ConnectionType.RECURRENT)
+
+            if RecurrentKind.LATERAL in recurrent:
+                # All neurons in this layer (old + new)
+                full_layer = list(self.layers[layer_idx].neurons)
+
+                for src in full_layer:
+                    for dst in new_neurons:
+                        if src is not dst:
+                            self.add_connection(
+                                src, dst, conn_type=ConnectionType.RECURRENT
+                            )
+
+            if RecurrentKind.INDIRECT in recurrent:
+                for src in new_neurons:
+                    for lower_layer in self.layers[1:layer_idx]:
+                        for dst in lower_layer.neurons:
+                            self.add_connection(
+                                src, dst, conn_type=ConnectionType.RECURRENT
+                            )
+                for higher_layer in self.layers[layer_idx + 1 :]:
+                    for src in higher_layer.neurons:
+                        for dst in new_neurons:
+                            self.add_connection(
+                                src, dst, conn_type=ConnectionType.RECURRENT
+                            )
+
+        return new_neurons
 
     def add_connection(
         self,
@@ -177,11 +214,11 @@ class Nnet:
         source.outgoing.append(conn)
         target.incoming.append(conn)
 
-    def reset(self) -> None:
+    def reset(self, full: bool = False) -> None:
         """Reset all neurons (clears input, output, and caches)."""
         for layer in self.layers:
             for neuron in layer.neurons:
-                neuron.reset()
+                neuron.reset(full=full)
 
     def calc(self, input_values: list[float]) -> list[float]:
         """
@@ -197,6 +234,11 @@ class Nnet:
             AssertionError: If input size does not match input layer.
         """
 
+        # Save LAST OUTPUT
+        for layer in self.layers:
+            for neuron in layer.neurons:
+                neuron.last_output = neuron.output
+
         self.reset()
 
         # Set inputs

{evonet-0.1.0.dev4 → evonet-0.1.0.dev6}/evonet/mutation.py

@@ -10,7 +10,7 @@ Includes:
 
 import random
 from collections.abc import Collection
-from typing import Optional
+from typing import Literal, Optional, Union, cast
 
 import numpy as np
 
@@ -20,6 +20,8 @@ from evonet.core import Nnet
 from evonet.enums import ConnectionType, NeuronRole, RecurrentKind
 from evonet.neuron import Neuron
 
+ALL_ACTIVATIONS = "all"
+
 
 def mutate_activation(neuron: Neuron, activations: list[str] | None = None) -> None:
     """
@@ -34,19 +36,78 @@ def mutate_activation(neuron: Neuron, activations: list[str] | None = None) -> N
 
 
 def mutate_activations(
-    net: Nnet, probability: float = 1.0, activations: list[str] | None = None
+    net: Nnet,
+    probability: float = 1.0,
+    activations: Optional[list[str]] = None,
+    layers: Optional[dict[int, Union[list[str], Literal["all"]]]] = None,
 ) -> None:
     """
-    Mutate the activation functions of non-input neurons in the network.
+    Mutate the activation functions of neurons with optional global or layer-specific
+    control.
+
+    Modes:
+        A) Default: Hidden layers are mutated using all available activation functions.
+        B) With `activations`: Hidden layers use a restricted set of activation
+           functions.
+        C) With `layers`: Only specified layers are mutated, each with their own
+           activation sets. This mode overrides the `activations` argument.
 
     Args:
-        net (Nnet): The target network.
-        probability (float): Mutation probability per neuron.
-        activations (list[str] | None): Optional subset of allowed activation functions.
+        net (Nnet): The target neural network.
+        probability (float): Mutation probability per neuron (must be in [0, 1]).
+        activations (list[str] | None): Optional list of allowed activation functions
+                                        (used in mode B).
+        layers (dict[int, list[str] | Literal["all"]] | None):
+            Optional per-layer activation sets (mode C).
+            If specified, overrides the `activations` argument.
+
+    Notes:
+        - Input and output layers are not mutated unless explicitly included
+          in `layers`.
+        - The function relies on `numpy.random.rand()` for random number generation.
+        - The `mutate_activation` function is called to perform the actual mutation of
+          a neuron's activation function.
+
+    Raises:
+        ValueError: If `probability` is not in [0, 1] or
+                    if `layers` contains invalid layer indices.
+
+    Example:
+        >>> net = Nnet(...)  # Assume a neural network with 3 layers
+        >>> mutate_activations(net, probability=0.5, activations=["relu", "sigmoid"])
+        >>> mutate_activations(net, layers={1: ["relu"], 2: "all"}, probability=0.3)
     """
-    for neuron in net.get_all_neurons():
-        if neuron.role != NeuronRole.INPUT and np.random.rand() < probability:
-            mutate_activation(neuron, activations)
+
+    if not 0 <= probability <= 1:
+        raise ValueError("Probability must be between 0 and 1.")
+
+    if layers is not None:
+        max_layer = len(net.layers)
+        invalid_layers = [i for i in layers if i < 0 or i >= max_layer]
+        if invalid_layers:
+            raise ValueError(
+                f"Invalid layer indices: {invalid_layers}."
+                f"Must be between 0 and {max_layer - 1}."
+            )
+
+    for layer_idx, layer in enumerate(net.layers):
+        if layers is not None:
+            if layer_idx not in layers:
+                continue
+
+            if layers[layer_idx] != ALL_ACTIVATIONS:
+                layer_activations = cast(list[str], layers[layer_idx])
+            else:
+                layer_activations = None  # None: mutate_activation uses all activations
+
+        elif layer_idx == 0 or layer_idx == len(net.layers) - 1:
+            continue
+        else:
+            layer_activations = activations
+
+        for neuron in layer.neurons:
+            if np.random.rand() < probability:
+                mutate_activation(neuron, layer_activations)
 
 
 def mutate_weight(conn: Connection, std: float = 0.1) -> None:
@@ -267,7 +328,7 @@ def split_connection(net: Nnet, activation: str = "tanh", noise: float = 0.1) ->
         role=NeuronRole.HIDDEN,
         activation=activation,
         connect_layer=False,
-    )
+    )[0]
 
     # Set new connections
     src.outgoing.remove(conn)

{evonet-0.1.0.dev4 → evonet-0.1.0.dev6}/evonet/neuron.py

@@ -55,18 +55,25 @@ class Neuron:
         self.last_output: float = 0.0
         self.label = label
 
-    def reset(self) -> None:
+    def reset(self, full: bool = False) -> None:
         """
-        Reset the neuron's state for a new forward pass.
+        Clear current neuron state for a new forward pass.
 
-        Sets:
-        - last_output = output
-        - output = 0.0
-        - input = 0.0
+        Args:
+            full (bool): If True, also clears `last_output` (used for recurrent memory).
+
+        This method:
+        - Always resets `input` and `output`.
+        - Only resets `last_output` if `full=True`.
+
+        Use `full=True` if the neuron should forget its prior state
+        (e.g. after fitness evaluation).
         """
-        self.last_output = self.output
+
         self.output = 0.0
         self.input = 0.0
+        if full:
+            self.last_output = 0.0
 
     def __repr__(self) -> str:
         """

{evonet-0.1.0.dev4 → evonet-0.1.0.dev6}/evonet.egg-info/PKG-INFO

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

{evonet-0.1.0.dev4 → evonet-0.1.0.dev6}/pyproject.toml

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

{evonet-0.1.0.dev4 → evonet-0.1.0.dev6}/tests/test_recurrent_dynamics.py

@@ -1,10 +1,11 @@
 import numpy as np
 
 from evonet.core import Nnet
-from evonet.enums import NeuronRole, ConnectionType
+from evonet.enums import ConnectionType, NeuronRole
+from evonet.neuron import Neuron
 
 
-def _mk_linear_ih_h_o() -> tuple[Nnet, object, object, object]:
+def _mk_linear_ih_h_o() -> tuple[Nnet, Neuron, Neuron, Neuron]:
     """
     Build a minimal 3-layer net (I-H-O), all linear activations, no auto-connections.
 
@@ -13,18 +14,20 @@ def _mk_linear_ih_h_o() -> tuple[Nnet, object, object, object]:
     net = Nnet()
     net.add_layer(3)  # input, hidden, output
 
-    n_in = net.add_neuron(layer_idx=0,
-                          role=NeuronRole.INPUT,
-                          activation="linear",
-                          connect_layer=False)
-    n_hid = net.add_neuron(layer_idx=1,
-                           role=NeuronRole.HIDDEN,
-                           activation="linear",
-                           connect_layer=False)
-    n_out = net.add_neuron(layer_idx=2,
-                           role=NeuronRole.OUTPUT,
-                           activation="linear",
-                           connect_layer=False)
+    neurons: list[Neuron] = net.add_neuron(
+        layer_idx=0, role=NeuronRole.INPUT, activation="linear", connect_layer=False
+    )
+    n_in = neurons[0]
+
+    neurons = net.add_neuron(
+        layer_idx=1, role=NeuronRole.HIDDEN, activation="linear", connect_layer=False
+    )
+    n_hid = neurons[0]
+
+    neurons = net.add_neuron(
+        layer_idx=2, role=NeuronRole.OUTPUT, activation="linear", connect_layer=False
+    )
+    n_out = neurons[0]
 
     return net, n_in, n_hid, n_out