evonet 0.1.0a0.dev1__tar.gz → 0.1.0.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evonet
-Version: 0.1.0a0.dev1
+Version: 0.1.0.dev3
 Summary: Evolvable neural network core for integration with EvoLib
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License
@@ -38,6 +38,7 @@ Requires-Dist: numpy>=1.24
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: pandas>=2.3.0
 Requires-Dist: pydantic<3.0,>=2.7
+Requires-Dist: graphviz>=0.20.1
 Provides-Extra: dev
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
@@ -52,10 +53,45 @@ 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**.
 
-## 🪪 License
+---
 
-This project is licensed under the [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
+## 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
+
+MIT License - see [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
 

evonet-0.1.0.dev3/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
+
+MIT License - see [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
+

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

@@ -2,12 +2,13 @@
 """
 Activation functions for evolvable neural networks.
 
-Provides scalar functions such as ReLU, Tanh, Sigmoid, as well as a softmax
-implementation and a function registry (ACTIVATIONS).
+Includes standard nonlinearities (ReLU, Tanh, Sigmoid), linear and threshold functions,
+modern smooth activations (Swish, Mish), and a softmax utility.
 
-These functions are stateless and operate on scalars unless otherwise noted.
+All functions are scalar-based and stateless, unless noted otherwise.
 """
 
+import random
 from typing import Callable, List, Tuple, Union
 
 import numpy as np
@@ -70,7 +71,7 @@ def gaussian(x: Scalar) -> float:
     return np.exp(-(x**2))
 
 
-# --- Threshold Functions ---
+# Threshold Functions
 
 
 def binary(x: Scalar) -> float:
@@ -83,7 +84,7 @@ def signum(x: Scalar) -> float:
     return 1.0 if x > 0 else -1.0 if x < 0 else 0.0
 
 
-# --- Linear Variants ---
+# Linear Variants
 
 
 def linear(x: Scalar) -> float:
@@ -154,13 +155,32 @@ def softmax(values: Union[List[float], Tuple[float], np.ndarray]) -> np.ndarray:
     return exp_x / np.sum(exp_x)
 
 
-# --- Registry ---
+def random_function_name(activations: list[str] | None = None) -> str:
+    """
+    Return a random activation function name from the registry.
+
+    Args:
+        activations (list[str] | None): Optional subset of allowed function names.
+            If None, all registered activation names are considered.
+
+    Raises:
+        ValueError: If any name is not in the activation registry.
+
+    Returns:
+        str: Randomly selected activation function name.
+    """
+
+    if activations is None:
+        activations = list(ACTIVATIONS.keys())
+
+    invalid = set(activations) - set(ACTIVATIONS.keys())
+    if invalid:
+        raise ValueError(f"Invalid activation functions: {invalid}")
 
+    return random.choice(activations)
 
-def random_function() -> str:
-    """Returns a random activation function name from the registry."""
-    return np.random.choice(list(ACTIVATIONS.keys()))
 
+# Registry
 
 ACTIVATIONS: dict[str, Callable] = {
     "tanh": tanh,

evonet-0.1.0.dev3/evonet/connection.py

@@ -0,0 +1,70 @@
+# 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}>"
+        )