evonet 0.1.0.dev7__tar.gz → 0.1.0.dev9__tar.gz

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/PKG-INFO

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

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/evonet/activation.py

@@ -203,4 +203,5 @@ ACTIVATIONS: dict[str, Callable] = {
     "softplus": softplus,
     "softsign": softsign,
     "hard_sigmoid": hard_sigmoid,
+    "softmax": softmax,
 }

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/evonet/core.py

@@ -9,11 +9,12 @@ export interfaces.
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Literal, Optional
 
 import graphviz
 import numpy as np
 
+from evonet.activation import softmax as softmax_vec
 from evonet.connection import Connection
 from evonet.enums import ConnectionType, NeuronRole, RecurrentKind
 from evonet.layer import Layer
@@ -100,31 +101,33 @@ class Nnet:
         label: str = "",
         role: NeuronRole = NeuronRole.HIDDEN,
         count: int = 1,
-        connect_layer: bool = True,
+        connection_init: Literal["random", "zero", "none"] = "random",
         recurrent: Optional[set[RecurrentKind]] = None,
     ) -> list[Neuron]:
         """
         Add one or more neurons to the network.
 
         Args:
-            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.
-            role (NeuronRole): Role of the neuron (INPUT, HIDDEN, OUTPUT).
-            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.
+            layer_idx: Target layer index. Defaults to last layer.
+            activation: Activation function name.
+            bias: Initial bias value.
+            label: Optional label.
+            role: Role of the neuron (INPUT, HIDDEN, OUTPUT).
+            count: Number of neurons to add (default: 1).
+            connection_init:
+                "random" – connect with random weights (feedforward + recurrent)
+                "zero"   – connect with weight 0.0 (feedforward + recurrent)
+                "none"   – do not create connections (feedforward + recurrent)
+            recurrent: Optional recurrent connection types.
 
         Returns:
             list[Neuron]: List of added neurons.
         """
-
         if layer_idx is None:
             layer_idx = len(self.layers) - 1  # Add neuron to last layer
 
         if layer_idx < 0:
-            raise ValueError(f"Expected positiv layerindex: got {layer_idx}")
+            raise ValueError(f"Layer index must be >= 0 (got {layer_idx})")
         if layer_idx >= len(self.layers):
             raise ValueError(f"Layer index out of bounds: {layer_idx}")
 
@@ -132,46 +135,56 @@ class Nnet:
         new_neurons: list[Neuron] = []
 
         # Create neurons without connections
-        for i in range(count):
+        for _ in range(count):
             neuron = Neuron(activation=activation, bias=bias)
             neuron.role = role
             neuron.label = label
             target_layer.neurons.append(neuron)
             new_neurons.append(neuron)
 
-        # Connect to previous layer (feedforward)
-        if connect_layer and layer_idx > 0:
+        # Weights based on init mode
+        weight_map = {"random": None, "zero": 0.0, "none": None}
+        if connection_init not in weight_map:
+            raise ValueError(f"Invalid connection_init: {connection_init}")
+        weight = weight_map[connection_init]
+
+        skip_connections = connection_init == "none"
+
+        # Connect to previous layer
+        if not skip_connections 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)
+                    self.add_connection(prev_neuron, n, weight=weight)
 
-        # Connect to next layer (feedforward)
+        # Connect to next layer (hidden only)
         if (
-            connect_layer
+            not skip_connections
             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)
+                    self.add_connection(n, next_neuron, weight=weight)
 
         # Recurrent connections
-        if recurrent:
+        if recurrent and not skip_connections:
             if RecurrentKind.DIRECT in recurrent:
                 for n in new_neurons:
                     if n.role == NeuronRole.HIDDEN:
-                        self.add_connection(n, n, conn_type=ConnectionType.RECURRENT)
+                        self.add_connection(
+                            n, n, weight=weight, 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
+                                src,
+                                dst,
+                                weight=weight,
+                                conn_type=ConnectionType.RECURRENT,
                             )
 
             if RecurrentKind.INDIRECT in recurrent:
@@ -179,13 +192,19 @@ class Nnet:
                     for lower_layer in self.layers[1:layer_idx]:
                         for dst in lower_layer.neurons:
                             self.add_connection(
-                                src, dst, conn_type=ConnectionType.RECURRENT
+                                src,
+                                dst,
+                                weight=weight,
+                                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
+                                src,
+                                dst,
+                                weight=weight,
+                                conn_type=ConnectionType.RECURRENT,
                             )
 
         return new_neurons
@@ -256,10 +275,28 @@ class Nnet:
 
         # Feed-forward by layers: activate first, then propagate non-recurrent edges
         for layer in self.layers:
+
+            # Apply softmax to all neurons with activation_name == "softmax"
+            softmax_neurons = [
+                n for n in layer.neurons if n.activation_name == "softmax"
+            ]
+            if softmax_neurons:
+                if len(softmax_neurons) >= 2:
+                    # Normal softmax behaviour
+                    totals = [n.input + n.bias for n in softmax_neurons]
+                    probabilities = softmax_vec(totals)
+                    for n, p in zip(softmax_neurons, probabilities):
+                        n.output = float(p)
+                else:
+                    # Fallback: single softmax neuron acts like identity
+                    n = softmax_neurons[0]
+                    n.output = n.input + n.bias
+
             # Activate all neurons in this layer
             for n in layer.neurons:
-                total = n.input + n.bias
-                n.output = n.activation(total)
+                if n.activation_name != "softmax":
+                    total = n.input + n.bias
+                    n.output = n.activation(total)
 
             # Propagate to targets (exclude recurrent edges)
             for n in layer.neurons:
@@ -326,7 +363,7 @@ class Nnet:
             ratio="fill",
             splines="spline",
             size="6.68,5!",
-            dpi="200",
+            dpi="600",
         )
         dot.node_attr.update(
             shape="circle", style="filled", fixedsize="shape", width="1.8"

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/evonet/mutation.py

@@ -270,7 +270,7 @@ def add_random_neuron(net: Nnet, activations: list[str] | None = None) -> None:
         layer_idx=net.layers.index(layer),
         activation=random_function_name(activations),
         role=NeuronRole.HIDDEN,
-        connect_layer=True,
+        connection_init="random",
     )
 
 
@@ -332,7 +332,7 @@ def split_connection(net: Nnet, activation: str = "tanh", noise: float = 0.1) ->
         layer_idx=insert_idx,
         role=NeuronRole.HIDDEN,
         activation=activation,
-        connect_layer=False,
+        connection_init="none",
     )[0]
 
     # Set new connections

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/evonet.egg-info/PKG-INFO

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

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/pyproject.toml

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

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/tests/test_core.py

@@ -13,14 +13,14 @@ def test_forward_pass_identity() -> None:
         activation="linear",
         role=NeuronRole.INPUT,
         label="in",
-        connect_layer=False,
+        connection_init="none",
     )
     net.add_neuron(
         layer_idx=1,
         activation="linear",
         role=NeuronRole.OUTPUT,
         label="out",
-        connect_layer=False,
+        connection_init="none",
     )
 
     src = net.layers[0].neurons[0]
@@ -49,7 +49,7 @@ def test_forward_pass_with_bias() -> None:
         activation="linear",
         role=NeuronRole.INPUT,
         label="in",
-        connect_layer=False,
+        connection_init="none",
     )
     net.add_neuron(
         layer_idx=1,
@@ -57,7 +57,7 @@ def test_forward_pass_with_bias() -> None:
         role=NeuronRole.OUTPUT,
         bias=0.5,
         label="out",
-        connect_layer=False,
+        connection_init="none",
     )
 
     src = net.layers[0].neurons[0]

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/tests/test_nnet_io_and_forward.py

@@ -29,21 +29,21 @@ def build_simple_ff_net() -> Nnet:
         role=NeuronRole.INPUT,
         activation="linear",
         count=2,
-        connect_layer=False,
+        connection_init="none",
     )
     net.add_neuron(
         layer_idx=1,
         role=NeuronRole.HIDDEN,
         activation="linear",
         count=3,
-        connect_layer=True,
+        connection_init="random",
     )
     net.add_neuron(
         layer_idx=2,
         role=NeuronRole.OUTPUT,
         activation="linear",
         count=1,
-        connect_layer=True,
+        connection_init="random",
     )
     return net
 
@@ -117,14 +117,14 @@ def test_forward_sanity_linear_1x1() -> None:
         role=NeuronRole.INPUT,
         activation="linear",
         count=1,
-        connect_layer=False,
+        connection_init="none",
     )
     net.add_neuron(
         layer_idx=1,
         role=NeuronRole.OUTPUT,
         activation="linear",
         count=1,
-        connect_layer=True,
+        connection_init="random",
     )
 
     # There should be exactly one connection L0(0) -> L1(0). Force known params:

{evonet-0.1.0.dev7 → evonet-0.1.0.dev9}/tests/test_recurrent_dynamics.py

@@ -15,17 +15,17 @@ def _mk_linear_ih_h_o() -> tuple[Nnet, Neuron, Neuron, Neuron]:
     net.add_layer(3)  # input, hidden, output
 
     neurons: list[Neuron] = net.add_neuron(
-        layer_idx=0, role=NeuronRole.INPUT, activation="linear", connect_layer=False
+        layer_idx=0, role=NeuronRole.INPUT, activation="linear", connection_init="none"
     )
     n_in = neurons[0]
 
     neurons = net.add_neuron(
-        layer_idx=1, role=NeuronRole.HIDDEN, activation="linear", connect_layer=False
+        layer_idx=1, role=NeuronRole.HIDDEN, activation="linear", connection_init="none"
     )
     n_hid = neurons[0]
 
     neurons = net.add_neuron(
-        layer_idx=2, role=NeuronRole.OUTPUT, activation="linear", connect_layer=False
+        layer_idx=2, role=NeuronRole.OUTPUT, activation="linear", connection_init="none"
     )
     n_out = neurons[0]