evonet 0.1.0__tar.gz

evonet-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 EvoLib
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

evonet-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: evonet
+Version: 0.1.0
+Summary: Evolvable neural network core for integration with EvoLib
+Author-email: EvoLib <evolib@dismail.de>
+License: MIT License
+        
+        Copyright (c) 2025 EvoLib
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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
+Requires-Dist: matplotlib
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Dynamic: license-file
+
+# 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: Beta](https://img.shields.io/badge/status-beta-blue.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 and explicit behaviour.
+
+---
+
+## Scope
+
+EvoNet is not a state-of-the-art or general-purpose deep learning framework.
+
+It does not aim to compete with libraries such as PyTorch, TensorFlow, or JAX in terms
+of performance, scalability, or training algorithms. Backpropagation, GPU acceleration,
+and highly optimised tensor operations are outside the scope of this project.
+
+Instead, EvoNet is designed for evolutionary algorithms, structural mutation, and
+exploratory research, with a focus on transparent and explicit implementations rather
+than performance optimisation or feature completeness.
+
+EvoNet should be understood as a conceptual and experimental model, not as a
+production-grade neural-network engine.
+
+---
+
+## Features
+
+- **Explicit, layer-based topology** with support for skip connections, cycles,
+  and recurrent paths
+- **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
+- **Topology-aware mutation operations**:
+  add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions**, configurable and evolvable
+- **Explicit 1-step recurrent state model**, without iterative stabilisation passes
+- **Runtime topology growth**, e.g. via `add_neuron` and `add_connection`
+- **Debug-friendly architecture** with explicit neuron IDs, labels, roles,
+  and directional graphs
+- **Designed for evolutionary integration**, not gradient-based training
+- **Lightweight and extensible**: pure Python, NumPy-based, no hard dependencies
+
+---
+
+> ⚠️ **Project status: Alpha**  
+> Interfaces, APIs, and internal structure may change as the project evolves.
+
+---
+
+## Quick Example
+
+```python
+from evonet.core import Nnet
+
+net = Nnet()
+net.add_layer()  # Input layer
+net.add_layer()  # Output layer
+
+net.add_neuron(layer_idx=0, activation="linear", label="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, label="out")
+
+print(net.calc([1.0]))
+```
+---
+
+## License
+
+MIT License - see [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
+

evonet-0.1.0/README.md

@@ -0,0 +1,72 @@
+# 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: Beta](https://img.shields.io/badge/status-beta-blue.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 and explicit behaviour.
+
+---
+
+## Scope
+
+EvoNet is not a state-of-the-art or general-purpose deep learning framework.
+
+It does not aim to compete with libraries such as PyTorch, TensorFlow, or JAX in terms
+of performance, scalability, or training algorithms. Backpropagation, GPU acceleration,
+and highly optimised tensor operations are outside the scope of this project.
+
+Instead, EvoNet is designed for evolutionary algorithms, structural mutation, and
+exploratory research, with a focus on transparent and explicit implementations rather
+than performance optimisation or feature completeness.
+
+EvoNet should be understood as a conceptual and experimental model, not as a
+production-grade neural-network engine.
+
+---
+
+## Features
+
+- **Explicit, layer-based topology** with support for skip connections, cycles,
+  and recurrent paths
+- **Typed neuron roles and connection types** (`NeuronRole`, `ConnectionType`)
+- **Topology-aware mutation operations**:
+  add/remove neurons and connections, mutate weights, change activations
+- **Per-neuron activation functions**, configurable and evolvable
+- **Explicit 1-step recurrent state model**, without iterative stabilisation passes
+- **Runtime topology growth**, e.g. via `add_neuron` and `add_connection`
+- **Debug-friendly architecture** with explicit neuron IDs, labels, roles,
+  and directional graphs
+- **Designed for evolutionary integration**, not gradient-based training
+- **Lightweight and extensible**: pure Python, NumPy-based, no hard dependencies
+
+---
+
+> ⚠️ **Project status: Alpha**  
+> Interfaces, APIs, and internal structure may change as the project evolves.
+
+---
+
+## Quick Example
+
+```python
+from evonet.core import Nnet
+
+net = Nnet()
+net.add_layer()  # Input layer
+net.add_layer()  # Output layer
+
+net.add_neuron(layer_idx=0, activation="linear", label="in")
+net.add_neuron(layer_idx=1, activation="linear", bias=0.5, label="out")
+
+print(net.calc([1.0]))
+```
+---
+
+## License
+
+MIT License - see [MIT License](https://github.com/EvoLib/evo-net/tree/main/LICENSE).
+

evonet-0.1.0/evonet/activation.py

@@ -0,0 +1,207 @@
+# SPDX-License-Identifier: MIT
+"""
+Activation functions for evolvable neural networks.
+
+Includes standard nonlinearities (ReLU, Tanh, Sigmoid), linear and threshold functions,
+modern smooth activations (Swish, Mish), and a softmax utility.
+
+All functions are scalar-based and stateless, unless noted otherwise.
+"""
+
+import random
+from typing import Callable, List, Tuple, Union
+
+import numpy as np
+
+Scalar = Union[int, float]
+
+
+# Common Activation Functions
+
+
+def tanh(x: Scalar) -> float:
+    """Hyperbolic tangent activation: [-inf, inf] --> [-1, 1]."""
+    return float(np.tanh(x))
+
+
+def ntanh(x: Scalar) -> float:
+    """Normalized tanh: (tanh(x) + 1) / 2 --> [0, 1]."""
+    return (np.tanh(x) + 1) / 2
+
+
+def sigmoid(x: Scalar) -> float:
+    """Sigmoid/logistic function: [-inf, inf] --> [0, 1]."""
+    x = np.clip(float(x), -500, 500)
+    return 1 / (1 + np.exp(-x))
+
+
+def relu(x: Scalar) -> float:
+    """ReLU: max(0, x)."""
+    return max(0.0, float(x))
+
+
+def relu_max1(x: Scalar) -> float:
+    """ReLU clipped to [0, 1]."""
+    return min(max(0.0, float(x)), 1.0)
+
+
+def leaky_relu(x: Scalar, alpha: float = 0.01) -> float:
+    """Leaky ReLU: x if x ≥ 0 else alpha * x."""
+    x = float(x)
+    return x if x >= 0 else alpha * x
+
+
+def elu(x: Scalar, alpha: float = 1.0) -> float:
+    """Exponential Linear Unit."""
+    x = float(x)
+    return x if x >= 0 else alpha * (np.exp(x) - 1)
+
+
+def selu(x: Scalar, alpha: float = 1.67326324, scale: float = 1.05070098) -> float:
+    """Scaled Exponential Linear Unit (SELU)."""
+    x = float(x)
+    return scale * x if x >= 0 else scale * alpha * (np.exp(x) - 1)
+
+
+def gaussian(x: Scalar) -> float:
+    """Gaussian bell function: exp(-x^2)."""
+    x = float(x)
+    if np.abs(x) > 38:
+        return 0.0
+    return np.exp(-(x**2))
+
+
+# Threshold Functions
+
+
+def binary(x: Scalar) -> float:
+    """Step function: 1 if x > 0 else 0."""
+    return 1.0 if x > 0 else 0.0
+
+
+def signum(x: Scalar) -> float:
+    """Sign function: 1, -1 or 0 depending on sign of x."""
+    return 1.0 if x > 0 else -1.0 if x < 0 else 0.0
+
+
+# Linear Variants
+
+
+def linear(x: Scalar) -> float:
+    """Linear identity: returns x."""
+    return float(x)
+
+
+def linear_max1(x: Scalar) -> float:
+    """Linear function clipped to [-1, 1]."""
+    return min(max(-1.0, float(x)), 1.0)
+
+
+def invert(x: Scalar) -> float:
+    """Returns -x."""
+    return -float(x)
+
+
+def null(_: Scalar = 0) -> float:
+    """Always returns 0.0."""
+    return 0.0
+
+
+# Modern Functions
+
+
+def swish(x: Scalar) -> float:
+    """Swish activation: x * sigmoid(x). Smooth and non-monotonic."""
+    return float(x) * sigmoid(x)
+
+
+def mish(x: Scalar) -> float:
+    """Mish activation: x * tanh(softplus(x))."""
+    return float(x) * np.tanh(np.log1p(np.exp(x)))
+
+
+def softplus(x: Scalar) -> float:
+    """Smooth ReLU approximation: log(1 + exp(x))."""
+    return np.log1p(np.exp(float(x)))
+
+
+def softsign(x: Scalar) -> float:
+    """Smooth alternative to tanh: x / (1 + |x|)."""
+    return float(x) / (1 + abs(float(x)))
+
+
+def hard_sigmoid(x: Scalar) -> float:
+    """Piecewise linear approximation of sigmoid."""
+    return min(max(0.0, 0.2 * float(x) + 0.5), 1.0)
+
+
+# Special Functions
+
+
+def softmax(values: Union[List[float], Tuple[float], np.ndarray]) -> np.ndarray:
+    """
+    Applies softmax over a list of values.
+
+    Args:
+        values: Array-like input with ≥2 values.
+
+    Returns:
+        np.ndarray: Normalized softmax output summing to 1.
+    """
+    arr = np.array(values, dtype=float)
+    if arr.size < 2:
+        raise ValueError("Softmax input must have at least two values")
+    exp_x = np.exp(arr - np.max(arr))  # For numerical stability
+    return exp_x / np.sum(exp_x)
+
+
+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)
+
+
+# Registry
+
+ACTIVATIONS: dict[str, Callable] = {
+    "tanh": tanh,
+    "ntanh": ntanh,
+    "sigmoid": sigmoid,
+    "relu": relu,
+    "relu_max1": relu_max1,
+    "leaky_relu": leaky_relu,
+    "elu": elu,
+    "selu": selu,
+    "gaussian": gaussian,
+    "binary": binary,
+    "signum": signum,
+    "linear": linear,
+    "linear_max1": linear_max1,
+    "invert": invert,
+    "null": null,
+    "swish": swish,
+    "mish": mish,
+    "softplus": softplus,
+    "softsign": softsign,
+    "hard_sigmoid": hard_sigmoid,
+    "softmax": softmax,
+}

evonet-0.1.0/evonet/connection.py

@@ -0,0 +1,126 @@
+# 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")
+
+        if conn_type is not ConnectionType.RECURRENT:
+            delay = 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}>"
+        )