evonet 0.1.0a0.dev1__tar.gz → 0.1.0a0.dev2__tar.gz

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0a0.dev1
+Version: 0.1.0a0.dev2
 Summary: Evolvable neural network core for integration with EvoLib
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License
@@ -52,8 +52,43 @@ Dynamic: license-file
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
 
-**EvoNet** is a modular, evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
-It supports dynamic topologies, recurrent connections, and is optimized for mutation, crossover, and structural evolution.
+**EvoNet** is a modular and evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
+It supports dynamic topologies, recurrent connections, per-neuron activation, and structural evolution – with a strong emphasis on **clarity**, **transparency**, and **didactic value**.
+
+---
+
+## 🔧 Features
+
+- **Layer-based but flexible** – allows skip connections, cycles, and recurrent paths
+- **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
+- **Topology-aware mutation system** – add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions** – configurable, extensible, evolvable
+- **1-step recurrent state logic** – avoids multi-pass stabilization
+- **Topology can grow at runtime** – with `add_neuron`, `add_connection`, `split_connection`
+- **Debug-friendly architecture** – explicit IDs, labels, roles, directional graphs
+- **Designed for evolutionary learning** – mutation, crossover, speciation ready
+- **Lightweight & extensible** – pure Python, NumPy-based, no hard dependencies
+
+---
+
+> ⚠️ **This project is in early development (alpha)**. Interfaces and structure may change.
+
+---
+
+## 🚀 Quick Example
+
+```python
+from evonet.core import Nnet
+
+net = Nnet()
+net.add_layer()  # Input
+net.add_layer()  # Output
+
+net.add_neuron(layer_idx=0, activation="linear", lable="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, lable="out", connect_layer=True)
+
+print(net.calc([1.0]))
+```
 
 ## 🪪 License
 

evonet-0.1.0a0.dev2/README.md

@@ -0,0 +1,47 @@
+# EvoNet
+[![Code Quality & Tests](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml/badge.svg)](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
+
+**EvoNet** is a modular and evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
+It supports dynamic topologies, recurrent connections, per-neuron activation, and structural evolution – with a strong emphasis on **clarity**, **transparency**, and **didactic value**.
+
+---
+
+## 🔧 Features
+
+- **Layer-based but flexible** – allows skip connections, cycles, and recurrent paths
+- **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
+- **Topology-aware mutation system** – add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions** – configurable, extensible, evolvable
+- **1-step recurrent state logic** – avoids multi-pass stabilization
+- **Topology can grow at runtime** – with `add_neuron`, `add_connection`, `split_connection`
+- **Debug-friendly architecture** – explicit IDs, labels, roles, directional graphs
+- **Designed for evolutionary learning** – mutation, crossover, speciation ready
+- **Lightweight & extensible** – pure Python, NumPy-based, no hard dependencies
+
+---
+
+> ⚠️ **This project is in early development (alpha)**. Interfaces and structure may change.
+
+---
+
+## 🚀 Quick Example
+
+```python
+from evonet.core import Nnet
+
+net = Nnet()
+net.add_layer()  # Input
+net.add_layer()  # Output
+
+net.add_neuron(layer_idx=0, activation="linear", lable="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, lable="out", connect_layer=True)
+
+print(net.calc([1.0]))
+```
+
+## 🪪 License
+
+This project is licensed under the [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
+

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/evonet/activation.py

@@ -154,14 +154,13 @@ def softmax(values: Union[List[float], Tuple[float], np.ndarray]) -> np.ndarray:
     return exp_x / np.sum(exp_x)
 
 
-# --- Registry ---
-
-
-def random_function() -> str:
+def random_function_name() -> str:
     """Returns a random activation function name from the registry."""
     return np.random.choice(list(ACTIVATIONS.keys()))
 
 
+# Registry
+
 ACTIVATIONS: dict[str, Callable] = {
     "tanh": tanh,
     "ntanh": ntanh,

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/evonet/connection.py

@@ -6,11 +6,9 @@ A connection links a source neuron to a target neuron with a weight. Supports op
 connection types for future use (e.g. inhibitory).
 """
 
-from __future__ import annotations
-
 from typing import TYPE_CHECKING
 
-from evonet.types import ConnectionType
+from evonet.enums import ConnectionType
 
 if TYPE_CHECKING:
     from evonet.neuron import Neuron
@@ -30,12 +28,13 @@ class Connection:
 
     def __init__(
         self,
-        source: Neuron,
-        target: Neuron,
+        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

evonet-0.1.0a0.dev2/evonet/core.py

@@ -0,0 +1,154 @@
+# SPDX-License-Identifier: MIT
+"""
+Core class for evolvable neural networks.
+
+Manages neurons, connections, and forward computation. Prepares mutation, crossover, and
+export interfaces.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from evonet.connection import Connection
+from evonet.enums import ConnectionType, NeuronRole
+from evonet.layer import Layer
+from evonet.neuron import Neuron
+
+
+class Nnet:
+    """
+    Evolvable neural network with explicit topology.
+
+    Attributes:
+        connections (list[Connection]): All directed, weighted edges.
+        input_neurons (list[Neuron]): Subset of neurons used as input nodes.
+        hidden_neurons (list[Neuron]): Subset of neurons used as hidden nodes.
+        output_neurons (list[Neuron]): Subset of neurons used as output nodes.
+    """
+
+    def __init__(self) -> None:
+        self.layers: list[Layer] = []
+
+    def add_layer(self, count: int = 1) -> int:
+        """
+        Add a layer to the network.
+
+        Parameter:
+            count (int): Number of layers to add
+        """
+
+        if count <= 0:
+            raise ValueError("Number of layers must be greater then zero")
+
+        for _ in range(count):
+            self.layers.append(Layer())
+
+        return len(self.layers) - 1
+
+    def add_neuron(
+        self,
+        layer_idx: int | None = None,
+        activation: str = "tanh",
+        bias: float = 0.0,
+        lable: str = "",
+        role: NeuronRole = NeuronRole.HIDDEN,
+        count: int = 1,
+        connect_layer: bool = True,
+    ) -> Neuron:
+
+        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}")
+        if layer_idx >= len(self.layers):
+            raise ValueError("Layerindex out off scope: got {layer_idx}")
+
+        for _ in range(count):
+            neuron = Neuron(activation=activation, bias=bias)
+            neuron.role = role
+            neuron.lable = lable
+
+            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
+        return neuron
+
+    def add_connection(
+        self,
+        source: Neuron,
+        target: Neuron,
+        weight: float | None = None,
+        conn_type: ConnectionType = ConnectionType.STANDARD,
+    ) -> None:
+
+        if weight is None:
+            weight = np.random.randn() * 0.5
+
+        conn = Connection(source, target, weight=weight, conn_type=conn_type)
+        source.outgoing.append(conn)
+        target.incoming.append(conn)
+
+    def reset(self) -> None:
+        """Resets all neurons."""
+        for layer in self.layers:
+            for neuron in layer.neurons:
+                neuron.reset()
+
+    def calc(self, input_values: list[float]) -> list[float]:
+
+        self.reset()
+
+        # Set Inputs
+        input_layer = self.layers[0]
+        assert len(input_layer.neurons) == len(input_values)
+        for idx, neuron in enumerate(input_layer.neurons):
+            neuron.input = float(input_values[idx])
+
+        # Recurrent
+        for layer in self.layers:
+            for neuron in layer.neurons:
+                for conn in neuron.incoming:
+                    if conn.type.name.lower() == "recurrent":
+                        neuron.input += conn.source.last_output * conn.weight
+                    else:
+                        neuron.input += conn.source.output * conn.weight
+
+        for layer in self.layers:
+            for neuron in layer.neurons:
+                total = neuron.input + neuron.bias
+                neuron.output = neuron.activation(total)
+                for conn in neuron.outgoing:
+                    conn.target.input += conn.weight * neuron.output
+
+        # Return Output
+        return [n.output for n in self.layers[-1].neurons]
+
+    def get_all_neurons(self) -> list[Neuron]:
+        return [n for layer in self.layers for n in layer.neurons]
+
+    def get_all_connections(self) -> list[Connection]:
+        return [c for n in self.get_all_neurons() for c in n.outgoing]
+
+    def __repr__(self) -> str:
+        total_neurons = sum(len(layer.neurons) for layer in self.layers)
+        input_neurons = len(self.layers[0].neurons) if self.layers else 0
+        output_neurons = len(self.layers[-1].neurons) if len(self.layers) > 1 else 0
+        hidden_neurons = total_neurons - input_neurons - output_neurons
+
+        total_connections = len(self.get_all_connections())
+
+        return (
+            f"<Nnet | {len(self.layers)} layers, "
+            f"{total_neurons} neurons (I:{input_neurons} H:{hidden_neurons} "
+            f"O:{output_neurons}), "
+            f"{total_connections} connections "
+        )

evonet-0.1.0a0.dev1/evonet/types.py → evonet-0.1.0a0.dev2/evonet/enums.py

@@ -14,3 +14,4 @@ class ConnectionType(Enum):
     INHIBITORY = auto()
     EXCITATORY = auto()
     MODULATORY = auto()
+    RECURRENT = auto()

evonet-0.1.0a0.dev2/evonet/layer.py

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: MIT
+from evonet.neuron import Neuron
+
+
+class Layer:
+    def __init__(self) -> None:
+        self.neurons: list[Neuron] = []
+
+    def add_neuron(self, neuron: Neuron) -> None:
+        self.neurons.append(neuron)

evonet-0.1.0a0.dev2/evonet/mutation.py

@@ -0,0 +1,137 @@
+# SPDX-License-Identifier: MIT
+"""
+Basic mutation operations for evolvable neural networks.
+
+Supports weight, bias, and structural mutations.
+"""
+
+import random
+
+import numpy as np
+
+from evonet.activation import ACTIVATIONS, random_function_name
+from evonet.connection import Connection
+from evonet.core import Nnet
+from evonet.enums import ConnectionType, NeuronRole
+from evonet.neuron import Neuron
+
+
+def mutate_activation(neuron: Neuron, std: float = 0.1) -> None:
+    neuron.activation_name = random_function_name()
+    neuron.activation = ACTIVATIONS[neuron.activation_name]
+
+
+def mutate_activations(net: Nnet, probability: float = 1.0, std: float = 0.1) -> None:
+    for neuron in net.get_all_neurons():
+        if neuron.role != NeuronRole.INPUT and np.random.rand() < probability:
+            mutate_activation(neuron)
+
+
+def mutate_weight(conn: Connection, std: float = 0.1) -> None:
+    conn.weight += np.random.normal(0, std)
+
+
+def mutate_weights(net: Nnet, probability: float = 1.0, std: float = 0.1) -> None:
+    """Applies Gaussian noise to all connection weights."""
+
+    for conn in net.get_all_connections():
+        if np.random.rand() < probability:
+            mutate_weight(conn, std)
+
+
+def mutate_bias(neuron: Neuron, std: float = 0.1) -> None:
+    neuron.bias += np.random.normal(0, std)
+
+
+def mutate_biases(net: Nnet, probability: float = 1.0, std: float = 0.1) -> None:
+    """Applies Gaussian noise to all neuron biases (except input neurons)."""
+    for neuron in net.get_all_neurons():
+        if neuron.role != NeuronRole.INPUT and np.random.rand() < probability:
+            mutate_bias(neuron, std)
+
+
+def add_random_connection(net: Nnet) -> None:
+    """Creates a new connection between two random Neuronen."""
+
+    all_neurons = net.get_all_neurons()
+    if len(all_neurons) < 2:
+        return
+
+    src = random.choice(all_neurons)
+    dst = random.choice(all_neurons)
+
+    if src == dst:
+        conn_type = ConnectionType.RECURRENT
+    else:
+        conn_type = ConnectionType.STANDARD
+
+    # Prüfen, ob Verbindung bereits existiert
+    if any(conn.target == dst for conn in src.outgoing):
+        return
+
+    net.add_connection(src, dst, conn_type=conn_type)
+
+
+def remove_random_connection(net: Nnet) -> None:
+    """Entfernt zufällig eine bestehende Verbindung."""
+    all_connections = net.get_all_connections()
+    if not all_connections:
+        return
+
+    conn = random.choice(all_connections)
+    conn.source.outgoing.remove(conn)
+    conn.target.incoming.remove(conn)
+
+
+def add_random_neuron(net: Nnet) -> None:
+    """Fügt ein neues Hidden-Neuron in ein zufälliges Layer ein und verbindet es mit
+    vorhandenen Neuronen."""
+    if len(net.layers) < 2:
+        return
+
+    # Ziel-Layer wählen (nicht Input, nicht Output)
+    candidate_layers = net.layers[1:-1]
+    if not candidate_layers:
+        return
+
+    layer = random.choice(candidate_layers)
+    net.add_neuron(
+        layer_idx=net.layers.index(layer),
+        activation="tanh",
+        role=NeuronRole.HIDDEN,
+        connect_layer=True,
+    )
+
+
+def split_connection(net: Nnet, activation: str = "tanh", noise: float = 0.1) -> None:
+    """Add Neuron between connection."""
+    all_connections = net.get_all_connections()
+    if not all_connections:
+        return
+
+    conn = random.choice(all_connections)
+    src, dst = conn.source, conn.target
+
+    insert_idx = None
+    for idx, layer in enumerate(net.layers):
+        if src in layer.neurons:
+            insert_idx = idx + 1
+            break
+
+    if insert_idx is None or insert_idx >= len(net.layers):
+        return
+
+    new_neuron = net.add_neuron(
+        layer_idx=insert_idx,
+        role=NeuronRole.HIDDEN,
+        activation=activation,
+        connect_layer=False,
+    )
+
+    # Set new connections
+    src.outgoing.remove(conn)
+    dst.incoming.remove(conn)
+
+    weight = 1.0 + np.random.normal(0, noise)
+    net.add_connection(src, new_neuron, weight=weight)
+    net.add_connection(new_neuron, dst, weight=conn.weight)

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/evonet/neuron.py

@@ -6,12 +6,12 @@ Each neuron holds its activation function, input/output connections, bias value,
 cached output from the last forward pass.
 """
 
-from __future__ import annotations
-
 from typing import Callable
 from uuid import uuid4
 
 from evonet.activation import ACTIVATIONS
+from evonet.connection import Connection
+from evonet.enums import NeuronRole
 
 
 class Neuron:
@@ -19,32 +19,44 @@ class Neuron:
     Represents a single neuron in the network.
 
     Attributes:
-        id (str): Unique identifier for tracking and crossover.
+        id (str): Unique identifier for tracking.
         activation_name (str): Name of the activation function.
         bias (float): Bias value added to incoming inputs.
         incoming (list): Incoming connections (to be filled externally).
         outgoing (list): Outgoing connections (to be filled externally).
         output (float): Cached result after activation.
+        lable (str): An optional lable
     """
 
-    def __init__(self, activation: str = "tanh", bias: float = 0.0) -> None:
+    def __init__(
+        self, activation: str = "tanh", lable: str = "", bias: float = 0.0
+    ) -> None:
+
         if activation not in ACTIVATIONS:
             raise ValueError(f"Unknown activation function: '{activation}'")
         self.id: str = str(uuid4())
+        self.role: NeuronRole = NeuronRole.HIDDEN
         self.activation_name: str = activation
         self.activation: Callable[[float], float] = ACTIVATIONS[activation]
         self.bias: float = bias
-        self.incoming: list = []
-        self.outgoing: list = []
+        self.incoming: list[Connection] = []
+        self.outgoing: list[Connection] = []
+        self.input: float = 0.0
         self.output: float = 0.0
+        self.last_output: float = 0.0
+        self.lable = lable
 
     def reset(self) -> None:
-        """Clears output before each forward pass."""
+        self.last_output = self.output
         self.output = 0.0
+        self.input = 0.0
 
     def __repr__(self) -> str:
         return (
-            f"<Neuron id={self.id[:6]} "
+            f"Neuron id={self.id[:6]} "
             f"act={self.activation_name} "
-            f"bias={self.bias:.2f}>"
+            f"role={self.role} "
+            f"bias={self.bias:.2f} "
+            f"input={self.input:0.5f} "
+            f"output={self.output:0.5f}"
         )

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/evonet.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0a0.dev1
+Version: 0.1.0a0.dev2
 Summary: Evolvable neural network core for integration with EvoLib
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License
@@ -52,8 +52,43 @@ Dynamic: license-file
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
 
-**EvoNet** is a modular, evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
-It supports dynamic topologies, recurrent connections, and is optimized for mutation, crossover, and structural evolution.
+**EvoNet** is a modular and evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
+It supports dynamic topologies, recurrent connections, per-neuron activation, and structural evolution – with a strong emphasis on **clarity**, **transparency**, and **didactic value**.
+
+---
+
+## 🔧 Features
+
+- **Layer-based but flexible** – allows skip connections, cycles, and recurrent paths
+- **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
+- **Topology-aware mutation system** – add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions** – configurable, extensible, evolvable
+- **1-step recurrent state logic** – avoids multi-pass stabilization
+- **Topology can grow at runtime** – with `add_neuron`, `add_connection`, `split_connection`
+- **Debug-friendly architecture** – explicit IDs, labels, roles, directional graphs
+- **Designed for evolutionary learning** – mutation, crossover, speciation ready
+- **Lightweight & extensible** – pure Python, NumPy-based, no hard dependencies
+
+---
+
+> ⚠️ **This project is in early development (alpha)**. Interfaces and structure may change.
+
+---
+
+## 🚀 Quick Example
+
+```python
+from evonet.core import Nnet
+
+net = Nnet()
+net.add_layer()  # Input
+net.add_layer()  # Output
+
+net.add_neuron(layer_idx=0, activation="linear", lable="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, lable="out", connect_layer=True)
+
+print(net.calc([1.0]))
+```
 
 ## 🪪 License
 

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/evonet.egg-info/SOURCES.txt

@@ -6,10 +6,11 @@ evonet/__init__.py
 evonet/activation.py
 evonet/connection.py
 evonet/core.py
+evonet/enums.py
 evonet/io.py
+evonet/layer.py
 evonet/mutation.py
 evonet/neuron.py
-evonet/types.py
 evonet/utils.py
 evonet/visualize.py
 evonet.egg-info/PKG-INFO

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/pyproject.toml

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

{evonet-0.1.0a0.dev1 → evonet-0.1.0a0.dev2}/tests/test_activation.py

@@ -23,8 +23,8 @@ def test_softmax_sum_to_one() -> None:
     np.testing.assert_almost_equal(np.sum(output), 1.0, decimal=6)
 
 
-def test_random_function_exists_in_registry() -> None:
-    """random_function must return a valid name in the registry."""
+def test_random_function_name_exists_in_registry() -> None:
+    """random_function_name must return a valid name in the registry."""
     for _ in range(10):
-        name = activation.random_function()
+        name = activation.random_function_name()
         assert name in activation.ACTIVATIONS

evonet-0.1.0a0.dev2/tests/test_core.py

@@ -0,0 +1,75 @@
+from evonet.core import Nnet
+from evonet.enums import NeuronRole
+
+
+def test_forward_pass_identity() -> None:
+    """Tests a minimal feedforward network with identity mapping."""
+    net = Nnet()
+    net.add_layer()  # Input layer
+    net.add_layer()  # Output layer
+
+    net.add_neuron(
+        layer_idx=0,
+        activation="linear",
+        role=NeuronRole.INPUT,
+        lable="in",
+        connect_layer=False,
+    )
+    net.add_neuron(
+        layer_idx=1,
+        activation="linear",
+        role=NeuronRole.OUTPUT,
+        lable="out",
+        connect_layer=False,
+    )
+
+    src = net.layers[0].neurons[0]
+    dst = net.layers[1].neurons[0]
+
+    net.add_connection(src, dst, weight=1.0)
+
+    # Gewicht prüfen
+    assert abs(src.outgoing[0].weight - 1.0) < 1e-6
+
+    result = net.calc([0.75])
+
+    assert isinstance(result, list)
+    assert len(result) == 1
+    assert abs(result[0] - 0.75) < 1e-6
+
+
+def test_forward_pass_with_bias() -> None:
+    """Tests a simple net with bias on the output neuron."""
+    net = Nnet()
+    net.add_layer()
+    net.add_layer()
+
+    net.add_neuron(
+        layer_idx=0,
+        activation="linear",
+        role=NeuronRole.INPUT,
+        lable="in",
+        connect_layer=False,
+    )
+    net.add_neuron(
+        layer_idx=1,
+        activation="linear",
+        role=NeuronRole.OUTPUT,
+        bias=0.5,
+        lable="out",
+        connect_layer=False,
+    )
+
+    src = net.layers[0].neurons[0]
+    dst = net.layers[1].neurons[0]
+
+    net.add_connection(src, dst, weight=2.0)
+
+    # Gewicht prüfen
+    assert abs(src.outgoing[0].weight - 2.0) < 1e-6
+
+    result = net.calc([1.0])
+
+    assert isinstance(result, list)
+    assert len(result) == 1
+    assert abs(result[0] - 2.5) < 1e-6  # (1.0 * 2.0) + 0.5 = 2.5

evonet-0.1.0a0.dev1/README.md

@@ -1,12 +0,0 @@
-# EvoNet
-[![Code Quality & Tests](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml/badge.svg)](https://github.com/EvoLib/evo-net/actions/workflows/ci.yml)
-[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Project Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](https://github.com/EvoLib/evo-net)
-
-**EvoNet** is a modular, evolvable neural network core designed for integration with [EvoLib](https://github.com/EvoLib/evo-lib).
-It supports dynamic topologies, recurrent connections, and is optimized for mutation, crossover, and structural evolution.
-
-## 🪪 License
-
-This project is licensed under the [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
-

evonet-0.1.0a0.dev1/evonet/core.py

@@ -1,117 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""
-Core class for evolvable neural networks.
-
-Manages neurons, connections, and forward computation. Prepares mutation, crossover, and
-export interfaces.
-"""
-
-from __future__ import annotations
-
-import numpy as np
-
-from evonet.connection import Connection
-from evonet.neuron import Neuron
-from evonet.types import NeuronRole
-
-
-class Nnet:
-    """
-    Evolvable neural network with explicit topology.
-
-    Attributes:
-        neurons (list[Neuron]): All neurons in the network.
-        connections (list[Connection]): All directed, weighted edges.
-        input_neurons (list[Neuron]): Subset of neurons used as input nodes.
-        output_neurons (list[Neuron]): Subset of neurons used as output nodes.
-    """
-
-    def __init__(self) -> None:
-        self.neurons: list[Neuron] = []
-        self.connections: list[Connection] = []
-        self.input_neurons: list[Neuron] = []
-        self.output_neurons: list[Neuron] = []
-
-    def add_neuron(self, neuron: Neuron, role: NeuronRole = NeuronRole.HIDDEN) -> None:
-        """Adds a neuron to the network and assigns its functional role."""
-        self.neurons.append(neuron)
-        if role == NeuronRole.INPUT:
-            self.input_neurons.append(neuron)
-        elif role == NeuronRole.OUTPUT:
-            self.output_neurons.append(neuron)
-
-    def add_connection(self, conn: Connection) -> None:
-        """Adds a connection and updates neuron references."""
-        self.connections.append(conn)
-        conn.target.incoming.append(conn)
-        conn.source.outgoing.append(conn)
-
-    def reset(self) -> None:
-        """Resets output values of all neurons (before forward pass)."""
-        for neuron in self.neurons:
-            neuron.reset()
-
-    def calc(self, input_values: list[float]) -> list[float]:
-        """
-        Forward pass through the network.
-
-        Args:
-            input_values: values to assign to input neurons
-
-        Returns:
-            outputs from output neurons (after activation)
-        """
-        assert len(input_values) == len(self.input_neurons), "Input size mismatch"
-        self.reset()
-
-        # Assign inputs
-        for i, value in enumerate(input_values):
-            self.input_neurons[i].output = float(value)
-
-        # Topological forward computation (assumes acyclic)
-        visited = set(self.input_neurons)
-        queue = [n for n in self.neurons if n not in visited]
-
-        while queue:
-            progressed = False
-            for neuron in queue[:]:
-                if all(src.source in visited for src in neuron.incoming):
-                    total = sum(c.get_signal() for c in neuron.incoming) + neuron.bias
-                    neuron.output = neuron.activation(total)
-                    visited.add(neuron)
-                    queue.remove(neuron)
-                    progressed = True
-            if not progressed:
-                break  # Prevent infinite loop
-
-        return [n.output for n in self.output_neurons]
-
-    def __repr__(self) -> str:
-        return (
-            f"<Nnet | {len(self.neurons)} neurons, "
-            f"{len(self.connections)} connections>"
-        )
-
-    def get_weights(self) -> np.ndarray:
-        """Returns all connection weights as a flat NumPy array."""
-        import numpy as np
-
-        return np.array([c.weight for c in self.connections], dtype=float)
-
-    def set_weights(self, vector: np.ndarray) -> None:
-        """Assigns connection weights from a flat NumPy array."""
-        assert len(vector) == len(self.connections), "Weight vector length mismatch"
-        for i, c in enumerate(self.connections):
-            c.weight = float(vector[i])
-
-    def get_biases(self) -> np.ndarray:
-        """Returns all neuron biases as a flat NumPy array."""
-        import numpy as np
-
-        return np.array([n.bias for n in self.neurons], dtype=float)
-
-    def set_biases(self, vector: np.ndarray) -> None:
-        """Assigns neuron biases from a flat NumPy array."""
-        assert len(vector) == len(self.neurons), "Bias vector length mismatch"
-        for i, n in enumerate(self.neurons):
-            n.bias = float(vector[i])

evonet-0.1.0a0.dev1/evonet/mutation.py

@@ -1,59 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""
-Mutation operators for evolvable neural networks.
-
-Includes mutations for weights, biases, and (optionally) activation functions. Structure
-mutations will be implemented separately.
-"""
-
-import random
-
-from evonet.core import Nnet
-
-
-def mutate_weights(
-    net: Nnet,
-    std: float = 0.1,
-    mutation_rate: float = 1.0,
-    weight_min: float = -5.0,
-    weight_max: float = 5.0,
-) -> None:
-    """
-    Applies Gaussian noise to connection weights.
-
-    Args:
-        net (Nnet): The network to mutate.
-        std (float): Standard deviation of noise.
-        mutation_rate (float): Probability per connection to mutate.
-        weight_min (float): Lower bound for weights.
-        weight_max (float): Upper bound for weights.
-    """
-    for conn in net.connections:
-        if random.random() < mutation_rate:
-            noise = random.gauss(0.0, std)
-            conn.weight += noise
-            conn.weight = max(min(conn.weight, weight_max), weight_min)
-
-
-def mutate_biases(
-    net: Nnet,
-    std: float = 0.1,
-    mutation_rate: float = 1.0,
-    bias_min: float = -5.0,
-    bias_max: float = 5.0,
-) -> None:
-    """
-    Applies Gaussian noise to neuron biases.
-
-    Args:
-        net (Nnet): The network to mutate.
-        std (float): Standard deviation of noise.
-        mutation_rate (float): Probability per neuron to mutate.
-        bias_min (float): Lower bound for biases.
-        bias_max (float): Upper bound for biases.
-    """
-    for neuron in net.neurons:
-        if random.random() < mutation_rate:
-            noise = random.gauss(0.0, std)
-            neuron.bias += noise
-            neuron.bias = max(min(neuron.bias, bias_max), bias_min)

evonet-0.1.0a0.dev1/tests/test_core.py

@@ -1,42 +0,0 @@
-from evonet.connection import Connection
-from evonet.core import Nnet
-from evonet.neuron import Neuron
-from evonet.types import NeuronRole
-
-
-def test_forward_pass_identity() -> None:
-    """Testet ein einfaches Netz mit einem Input und einem Output."""
-    net = Nnet()
-
-    # Neuronen erstellen
-    n_input = Neuron(activation="linear")
-    n_output = Neuron(activation="linear")
-
-    # Netz aufbauen
-    net.add_neuron(n_input, role=NeuronRole.INPUT)
-    net.add_neuron(n_output, role=NeuronRole.OUTPUT)
-    net.add_connection(Connection(n_input, n_output, weight=1.0))
-
-    # Eingabe --> Ausgabe testen
-    x = [0.75]
-    y = net.calc(x)
-
-    assert isinstance(y, list)
-    assert len(y) == 1
-    assert abs(y[0] - 0.75) < 1e-6
-
-
-def test_forward_pass_with_bias() -> None:
-    """Testet Netz mit Bias am Output-Neuron."""
-    net = Nnet()
-
-    n_input = Neuron(activation="linear")
-    n_output = Neuron(activation="linear", bias=0.5)
-
-    net.add_neuron(n_input, role=NeuronRole.INPUT)
-    net.add_neuron(n_output, role=NeuronRole.OUTPUT)
-    net.add_connection(Connection(n_input, n_output, weight=2.0))
-
-    y = net.calc([1.0])
-
-    assert abs(y[0] - 2.5) < 1e-6  # (1.0 * 2.0) + 0.5 = 2.5