evonet 0.1.0a0.dev1__tar.gz

evonet-0.1.0a0.dev1/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.0a0.dev1/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: evonet
+Version: 0.1.0a0.dev1
+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
+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, 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/README.md

@@ -0,0 +1,12 @@
+# 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/activation.py

@@ -0,0 +1,186 @@
+# SPDX-License-Identifier: MIT
+"""
+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).
+
+These functions are stateless and operate on scalars unless otherwise noted.
+"""
+
+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)
+
+
+# --- Registry ---
+
+
+def random_function() -> str:
+    """Returns a random activation function name from the registry."""
+    return np.random.choice(list(ACTIVATIONS.keys()))
+
+
+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,
+}

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

@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: MIT
+"""
+Connection between neurons in evolvable neural network.
+
+A connection links a source neuron to a target neuron with a weight. Supports optional
+connection types for future use (e.g. inhibitory).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from evonet.types 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 signal.
+        delay (int): Optional delay in steps (not yet used).
+        type (ConnectionType): Type of the connection (e.g. excitatory).
+    """
+
+    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:
+        """Computes the weighted signal from the source neuron."""
+        return self.source.output * self.weight
+
+    def __repr__(self) -> str:
+        type_str = self.type.name.lower()
+        return (
+            f"<Conn {self.source.id[:4]} "
+            f"-> {self.target.id[:4]} "
+            f"w={self.weight:.2f} type={type_str}>"
+        )

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

@@ -0,0 +1,117 @@
+# 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

@@ -0,0 +1,59 @@
+# 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/evonet/neuron.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: MIT
+"""
+Neuron definition for evolvable neural network.
+
+Each neuron holds its activation function, input/output connections, bias value, and a
+cached output from the last forward pass.
+"""
+
+from __future__ import annotations
+
+from typing import Callable
+from uuid import uuid4
+
+from evonet.activation import ACTIVATIONS
+
+
+class Neuron:
+    """
+    Represents a single neuron in the network.
+
+    Attributes:
+        id (str): Unique identifier for tracking and crossover.
+        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.
+    """
+
+    def __init__(self, activation: str = "tanh", bias: float = 0.0) -> None:
+        if activation not in ACTIVATIONS:
+            raise ValueError(f"Unknown activation function: '{activation}'")
+        self.id: str = str(uuid4())
+        self.activation_name: str = activation
+        self.activation: Callable[[float], float] = ACTIVATIONS[activation]
+        self.bias: float = bias
+        self.incoming: list = []
+        self.outgoing: list = []
+        self.output: float = 0.0
+
+    def reset(self) -> None:
+        """Clears output before each forward pass."""
+        self.output = 0.0
+
+    def __repr__(self) -> str:
+        return (
+            f"<Neuron id={self.id[:6]} "
+            f"act={self.activation_name} "
+            f"bias={self.bias:.2f}>"
+        )

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

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum, auto
+
+
+class NeuronRole(Enum):
+    INPUT = auto()
+    HIDDEN = auto()
+    OUTPUT = auto()
+    BIAS = auto()
+
+
+class ConnectionType(Enum):
+    STANDARD = auto()
+    INHIBITORY = auto()
+    EXCITATORY = auto()
+    MODULATORY = auto()

evonet-0.1.0a0.dev1/evonet.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: evonet
+Version: 0.1.0a0.dev1
+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
+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, 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.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+evonet/__init__.py
+evonet/activation.py
+evonet/connection.py
+evonet/core.py
+evonet/io.py
+evonet/mutation.py
+evonet/neuron.py
+evonet/types.py
+evonet/utils.py
+evonet/visualize.py
+evonet.egg-info/PKG-INFO
+evonet.egg-info/SOURCES.txt
+evonet.egg-info/dependency_links.txt
+evonet.egg-info/requires.txt
+evonet.egg-info/top_level.txt
+tests/test_activation.py
+tests/test_core.py

evonet-0.1.0a0.dev1/evonet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

evonet-0.1.0a0.dev1/evonet.egg-info/requires.txt

@@ -0,0 +1,13 @@
+numpy>=1.24
+pyyaml>=6.0
+pandas>=2.3.0
+pydantic<3.0,>=2.7
+
+[dev]
+mypy
+types-PyYAML
+
+[docs]
+sphinx
+sphinx-rtd-theme
+myst-parser

evonet-0.1.0a0.dev1/evonet.egg-info/top_level.txt

@@ -0,0 +1 @@
+evonet

evonet-0.1.0a0.dev1/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "evonet"
+version = "0.1.0adev1"
+description = "Evolvable neural network core for integration with EvoLib"
+authors = [
+    { name = "EvoLib", email = "evolib@dismail.de" }
+]
+license = { file = "LICENSE" }
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy >=1.24",
+    "pyyaml >=6.0",
+    "pandas >=2.3.0",
+    "pydantic >= 2.7,<3.0"
+]
+
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence"
+]
+
+[project.optional-dependencies]
+dev = ["mypy","types-PyYAML"]
+docs = [
+  "sphinx",
+  "sphinx-rtd-theme",
+  "myst-parser",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["evonet*"]
+
+[tool.setuptools.package-data]
+"evolib" = ["py.typed"]
+
+# Tool-Konfigurationen
+[tool.black]
+line-length = 88
+target-version = ["py311"]
+
+[tool.isort]
+profile = "black"
+line_length = 88
+
+[tool.mypy]
+python_version = "3.12"
+ignore_missing_imports = true
+disallow_untyped_defs = true
+check_untyped_defs = true
+warn_unused_ignores = true
+
+[tool.flake8]
+max-line-length = 88
+extend-ignore = ["E203", "W503"]
+
+[tool.docformatter]
+wrap-summaries = 88
+wrap-descriptions = 88
+pre-summary-newline = true
+
+[tool.pylint]
+max-line-length = 88
+disable = [
+    "missing-docstring",
+    "invalid-name",
+    "too-few-public-methods",
+    "too-many-arguments",
+    "too-many-instance-attributes",
+    "too-many-locals"
+]
+

evonet-0.1.0a0.dev1/setup.cfg

@@ -0,0 +1,8 @@
+[flake8]
+max-line-length = 88
+extend-ignore = E203, W503
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

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

@@ -0,0 +1,30 @@
+import numpy as np
+import pytest
+
+from evonet import activation
+
+
+@pytest.mark.parametrize("x", [-2.0, 0.0, 2.0])
+def test_activation_outputs_finite(x: float) -> None:
+    """All scalar activations should return a finite float."""
+    for name, fn in activation.ACTIVATIONS.items():
+        if name == "softmax":
+            continue  # handled separately
+        y = fn(x)
+        assert isinstance(y, float), f"{name} did not return float"
+        assert np.isfinite(y), f"{name} returned non-finite value: {y}"
+
+
+def test_softmax_sum_to_one() -> None:
+    """Softmax output should sum to 1.0."""
+    input_vector = [1.0, 2.0, 3.0]
+    output = activation.softmax(input_vector)
+    assert isinstance(output, np.ndarray)
+    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."""
+    for _ in range(10):
+        name = activation.random_function()
+        assert name in activation.ACTIVATIONS

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

@@ -0,0 +1,42 @@
+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