evonet 0.1.0.dev23__tar.gz

evonet-0.1.0.dev23/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.dev23/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: evonet
+Version: 0.1.0.dev23
+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: 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.0.dev23/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.0.dev23/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.dev23/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}>"
+        )