evolib 0.2.0b2.dev4__tar.gz → 0.2.0b2.dev5__tar.gz

{evolib-0.2.0b2.dev4/evolib.egg-info → evolib-0.2.0b2.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b2.dev4
+Version: 0.2.0b2.dev5
 Summary: A modular framework for evolutionary strategies and neuroevolution.
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/evolib/core/individual.py

@@ -24,13 +24,14 @@ from typing import Any, Dict, Optional
 from uuid import uuid4
 
 from evolib.interfaces.enums import Origin
+from evolib.representation.dummy import ParaDummy
 
 
 class Indiv:
     """Represents an individual in an evolutionary optimization algorithm."""
 
-    #: para (Any, optional): Parameter values of the individual. Default: None.
-    para: Any | None
+    #: para (Any): Parameter values of the individual. Default: None.
+    para: Any
 
     #: fitness (float): Fitness value of the individual.
     #: None means the individual has not yet been evaluated.
@@ -73,9 +74,9 @@ class Indiv:
         "is_elite",
     )
 
-    def __init__(self, para: Any | None = None):
+    def __init__(self, para: Any = None):
         self.id: str = str(uuid4())
-        self.para = para
+        self.para = para if para is not None else ParaDummy()
         self.fitness = None
         self.is_evaluated = False
         self.age = 0

evolib-0.2.0b2.dev5/evolib/initializers/evonet_initializers.py

@@ -0,0 +1,144 @@
+# SPDX-License-Identifier: MIT
+"""
+Initializers for EvoNet networks.
+
+These initializers convert a module configuration with `type: evonet` into a fully
+initialized EvoNet instance.
+"""
+
+import numpy as np
+from evonet.activation import random_function_name
+from evonet.enums import NeuronRole
+
+from evolib.config.evonet_component_config import EvoNetComponentConfig
+from evolib.config.schema import FullConfig
+from evolib.interfaces.enum_helpers import resolve_recurrent_kinds
+from evolib.representation.evonet import EvoNet
+
+
+def _build_architecture(para: EvoNet, cfg: EvoNetComponentConfig) -> None:
+    """
+    Build the EvoNet architecture (layers, neurons, activations) from config.
+
+    Args:
+        para (EvoNet): The EvoNet instance (already has parameters set).
+        cfg (EvoNetComponentConfig): Config with architecture definition.
+    """
+    # Activation functions per layer
+    if isinstance(cfg.activation, list):
+        activations = cfg.activation
+    else:
+        # Input layer linear, others same activation
+        activations = ["linear"] + [cfg.activation] * (len(cfg.dim) - 1)
+
+    for layer_idx, num_neurons in enumerate(cfg.dim):
+        if num_neurons == 0:
+            continue
+
+        activation_name = activations[layer_idx]
+        if activation_name == "random":
+            if cfg.activations_allowed is not None:
+                activation_name = random_function_name(cfg.activations_allowed)
+            else:
+                activation_name = random_function_name()
+
+        para.net.add_layer()
+
+        if layer_idx == 0:
+            role = NeuronRole.INPUT
+        elif layer_idx == len(cfg.dim) - 1:
+            role = NeuronRole.OUTPUT
+        else:
+            role = NeuronRole.HIDDEN
+
+        recurrent_kinds = resolve_recurrent_kinds(cfg.recurrent)
+        para.net.add_neuron(
+            count=num_neurons,
+            activation=activation_name,
+            role=role,
+            connection_init="zero",
+            bias=0.0,
+            recurrent=recurrent_kinds if role != NeuronRole.INPUT else None,
+        )
+
+
+def initializer_normal_evonet(config: FullConfig, module: str) -> EvoNet:
+    """
+    Initializes an EvoNet with normally distributed weights.
+
+    Args:
+        config (FullConfig): Full experiment configuration
+        module (str): Module name (e.g. "brain")
+
+    Returns:
+        EvoNet: Initialized EvoNet representation
+    """
+    para = EvoNet()
+    cfg = config.modules[module].model_copy(deep=True)
+    para.apply_config(cfg)
+
+    _build_architecture(para, cfg)
+
+    # Initialize weights and biases with normal distribution
+    weights = np.random.normal(loc=0.0, scale=0.5, size=para.net.num_weights)
+    biases = np.random.normal(loc=0.0, scale=0.5, size=para.net.num_biases)
+
+    para.net.set_weights(weights)
+    para.net.set_biases(biases)
+    return para
+
+
+def initializer_random_evonet(config: FullConfig, module: str) -> EvoNet:
+    """
+    Initializes an EvoNet with uniformly random weights and biases within init_bounds
+    (fallback: weight_bounds, bias_bounds).
+
+    Args:
+        config (FullConfig): Full experiment configuration
+        module (str): Module name
+
+    Returns:
+        EvoNet: Initialized EvoNet representation
+    """
+    para = EvoNet()
+    cfg = config.modules[module].model_copy(deep=True)
+    para.apply_config(cfg)
+
+    _build_architecture(para, cfg)
+
+    # Use weight_bounds if available, else fall back to bounds
+    weight_bounds = cfg.weight_bounds or (-1.0, 1.0)
+    min_weight = weight_bounds[0]
+    max_weight = weight_bounds[1]
+    bias_bounds = cfg.bias_bounds or (-0.5, 0.5)
+    min_bias = bias_bounds[0]
+    max_bias = bias_bounds[1]
+
+    weights = np.random.uniform(min_weight, max_weight, size=para.net.num_weights)
+    biases = np.random.uniform(min_bias, max_bias, size=para.net.num_biases)
+
+    para.net.set_weights(weights)
+    para.net.set_biases(biases)
+    return para
+
+
+def initializer_zero_evonet(config: FullConfig, module: str) -> EvoNet:
+    """
+    Initializes an EvoNet with all weights and biases set to zero.
+
+    Args:
+        config (FullConfig): Full experiment configuration
+        module (str): Module name
+
+    Returns:
+        EvoNet: Initialized EvoNet representation
+    """
+    para = EvoNet()
+    cfg = config.modules[module].model_copy(deep=True)
+    para.apply_config(cfg)
+
+    _build_architecture(para, cfg)
+
+    para.net.set_weights(np.zeros(para.net.num_weights))
+    para.net.set_biases(np.zeros(para.net.num_biases))
+    return para

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/evolib/initializers/registry.py

@@ -16,7 +16,11 @@ from typing import Any, Callable
 from evolib.config.schema import FullConfig
 
 # EvoNet-based initializer
-from evolib.initializers.evonet_initializers import initializer_normal_evonet
+from evolib.initializers.evonet_initializers import (
+    initializer_normal_evonet,
+    initializer_random_evonet,
+    initializer_zero_evonet,
+)
 
 # NetVector-based initializer
 from evolib.initializers.net_initializers import initializer_normal_net
@@ -45,6 +49,8 @@ INITIALIZER_REGISTRY: dict[str, InitializerFunction] = {
     "adaptive_vector": initializer_adaptive_vector,
     "normal_net": initializer_normal_net,
     "normal_evonet": initializer_normal_evonet,
+    "random_evonet": initializer_random_evonet,
+    "zero_evonet": initializer_zero_evonet,
 }
 
 

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/evolib/operators/crossover.py

@@ -196,9 +196,11 @@ def crossover_intermediate(
 
 def crossover_offspring(pop: "Pop", offspring: list["Indiv"]) -> None:
     """
-    Perform crossover for each pair of offspring individuals. Supports ParaComposite by
-    applying module-specific crossover operators and probabilities defined in the
-    configuration.
+    Perform crossover for each pair of offspring individuals.
+
+    Delegates the actual crossover logic to the individuals' parameter
+    representations (ParaBase subclasses). Works for both single-module
+    (e.g. Vector, EvoNet) and multi-module (ParaComposite) individuals.
 
     Notes:
         - Offspring are assumed to be copied before this call.
@@ -216,20 +218,11 @@ def crossover_offspring(pop: "Pop", offspring: list["Indiv"]) -> None:
         if child1.para is None or child2.para is None:
             continue
 
-        for module_name in child1.para.components:
-            module1 = child1.para.components[module_name]
-            module2 = child2.para.components[module_name]
-
-            prob1 = module1.evo_params.crossover_probability
-            prob2 = module2.evo_params.crossover_probability
-
-            if prob1 is None or prob2 is None:
-                continue
-
-            effective_prob = min(prob1, prob2)
-
-            if effective_prob <= 0.0 or np.random.rand() >= effective_prob:
-                continue
-
-            # Perform crossover
-            module1.crossover_with(module2)
+        # Delegate crossover to para (Vector, EvoNet, or ParaComposite)
+        try:
+            child1.para.crossover_with(child2.para)
+        except Exception as e:
+            # Optional: log or raise, depending on how strict du es haben willst
+            raise RuntimeError(
+                f"Crossover failed for individuals {child1.id} and {child2.id}: {e}"
+            )

evolib-0.2.0b2.dev5/evolib/representation/dummy.py

@@ -0,0 +1,31 @@
+"""
+Placeholder implementation of ParaBase for uninitialized individuals.
+
+Ensures that every individual always has a ParaBase instance, even before configuration.
+All operations (mutation, crossover, apply_config) raise clear errors to prevent
+accidental use of uninitialized parameters.
+"""
+
+from typing import Any
+
+from evolib.interfaces.types import ModuleConfig
+from evolib.representation.base import ParaBase
+
+
+class ParaDummy(ParaBase):
+    """Placeholder ParaBase used for uninitialized individuals."""
+
+    def apply_config(self, cfg: ModuleConfig) -> None:
+        raise RuntimeError("DummyPara cannot be configured.")
+
+    def mutate(self) -> None:
+        raise RuntimeError("DummyPara cannot be mutated.")
+
+    def print_status(self) -> None:
+        print("[DummyPara] (no parameters)")
+
+    def get_status(self) -> str | dict[str, Any]:
+        return "<DummyPara: no parameters>"
+
+    def crossover_with(self, partner: "ParaBase") -> None:
+        raise RuntimeError("DummyPara cannot participate in crossover.")

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/evolib/representation/evonet.py

@@ -10,14 +10,12 @@ import random as rng
 from typing import Any, Literal, Optional
 
 import numpy as np
-from evonet.activation import random_function_name
 from evonet.core import Nnet
 from evonet.enums import NeuronRole
 from evonet.mutation import mutate_activations, mutate_bias, mutate_weight
 
 from evolib.config.base_component_config import StructuralMutationConfig
 from evolib.config.evonet_component_config import EvoNetComponentConfig
-from evolib.interfaces.enum_helpers import resolve_recurrent_kinds
 from evolib.interfaces.enums import MutationStrategy
 from evolib.interfaces.types import ModuleConfig
 from evolib.operators.evonet_structural_mutation import mutate_structure
@@ -112,46 +110,6 @@ class EvoNet(ParaBase):
         # Apply crossover config
         apply_crossover_config(evo_params, cfg.crossover)
 
-        # Activation functions per layer
-        if isinstance(cfg.activation, list):
-            activations = cfg.activation
-        else:
-            # Apply the same activation to all hidden/output layers,
-            # but force input layer to be linear
-            activations = ["linear"] + [cfg.activation] * (len(cfg.dim) - 1)
-
-        for layer_idx, num_neurons in enumerate(self.dim):
-            if num_neurons == 0:
-                continue
-
-            activation_name = activations[layer_idx]
-
-            if activation_name == "random":
-                if cfg.activations_allowed is not None:
-                    activation_name = random_function_name(cfg.activations_allowed)
-                else:
-                    activation_name = random_function_name()
-
-            self.net.add_layer()
-
-            if layer_idx == 0:
-                # Input Layer
-                role = NeuronRole.INPUT
-            elif layer_idx == len(self.dim) - 1:
-                # Output Layer
-                role = NeuronRole.OUTPUT
-            else:
-                # Hidden Layer
-                role = NeuronRole.HIDDEN
-
-            recurrent_kinds = resolve_recurrent_kinds(cfg.recurrent)
-            self.net.add_neuron(
-                count=num_neurons,
-                activation=activation_name,
-                role=role,
-                recurrent=recurrent_kinds if role != NeuronRole.INPUT else None,
-            )
-
     def calc(self, input_values: list[float]) -> list[float]:
         return self.net.calc(input_values)
 

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/evolib/utils/benchmarks.py

@@ -1,9 +1,107 @@
 # SPDX-License-Identifier: MIT
 """Common mathematical benchmark functions for optimization tasks."""
 
+from typing import Sequence
+
 import numpy as np
 
 
+def lfsr_sequence(
+    length: int,
+    seed: int = 0b10011,
+    taps: tuple[int, ...] = (5, 2),
+    invert_feedback: bool = True,
+) -> list[int]:
+    """
+    Generate a binary sequence using an n-bit LFSR (Linear Feedback Shift Register).
+
+    Parameters
+    ----------
+    length : int
+        Number of output bits to generate.
+    seed : int, optional
+        Initial state of the LFSR (must be non-zero). Default: 0b10011.
+    taps : tuple[int, ...], optional
+        Tap positions (1-based, e.g. (5, 2) for x^5 + x^2 + 1).
+    invert_feedback : bool, optional
+        If True (default), the feedback bit is inverted at initialization.
+        This variant ensures a maximal-length sequence for (5, 2).
+        If False, the classical Fibonacci-LFSR update rule is used.
+
+    Returns
+    -------
+    list[int]
+        Generated bit sequence of the given length.
+    """
+    n = max(taps)
+    if seed == 0:
+        raise ValueError("Seed must be non-zero for LFSR.")
+
+    state = seed & ((1 << n) - 1)
+    seq: list[int] = []
+
+    for _ in range(length):
+        bit = state & 1
+        seq.append(bit)
+
+        fb = 1 if invert_feedback else 0
+        for t in taps:
+            fb ^= (state >> (t - 1)) & 1
+
+        state = (state >> 1) | (fb << (n - 1))
+
+    return seq
+
+
+def xor_sequence(length: int, k: int = 2, seed: Sequence[int] = (0, 1)) -> list[int]:
+    """
+    Generate a sequence where each new bit is the XOR of the last k bits.
+
+    Parameters
+    ----------
+    length : int
+        Length of the sequence to generate.
+    k : int, optional
+        Window size for XOR. Default: 2 (classic XOR sequence).
+    seed : Sequence[int], optional
+        Initial bits to start the sequence. Must have length >= k.
+
+    Returns
+    -------
+    list[int]
+        Generated bit sequence of the given length.
+    """
+    if len(seed) < k:
+        raise ValueError(f"Seed must have at least {k} bits.")
+    seq = list(seed)
+    while len(seq) < length:
+        next_bit = 0
+        for i in range(1, k + 1):
+            next_bit ^= seq[-i]
+        seq.append(next_bit)
+    return seq[:length]
+
+
+def random_fixed_sequence(length: int, seed: int = 1234) -> list[int]:
+    """
+    Generate a reproducible random bit sequence with a fixed seed.
+
+    Parameters
+    ----------
+    length : int
+        Length of the sequence.
+    seed : int, optional
+        Random seed for reproducibility. Default: 1234.
+
+    Returns
+    -------
+    list[int]
+        Generated random bit sequence (0/1).
+    """
+    rng = np.random.RandomState(seed)
+    return rng.randint(0, 2, size=length).tolist()
+
+
 def simple_quadratic(x: np.ndarray) -> float:
     """
     Simple 1D benchmark: f(x) = x^2

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/evolib/utils/plotting.py

@@ -632,6 +632,9 @@ def plot_bit_prediction(
     axes[1].set_ylabel("Value")
     axes[1].legend(loc="upper right")
 
+    # add threshold line at 0.5
+    axes[1].axhline(0.5, color="gray", linestyle="--", linewidth=1, alpha=0.6)
+
     # save/show
     if save_path:
         os.makedirs(os.path.dirname(save_path), exist_ok=True)

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5/evolib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b2.dev4
+Version: 0.2.0b2.dev5
 Summary: A modular framework for evolutionary strategies and neuroevolution.
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/evolib.egg-info/SOURCES.txt

@@ -306,6 +306,7 @@ evolib/representation/__init__.py
 evolib/representation/_apply_config_mapping.py
 evolib/representation/base.py
 evolib/representation/composite.py
+evolib/representation/dummy.py
 evolib/representation/evo_params.py
 evolib/representation/evonet.py
 evolib/representation/netvector.py
@@ -445,7 +446,7 @@ examples/06_netvector/03_netvector_gain_and_bias.py
 examples/07_evonet/01_sine_approximation.py
 examples/07_evonet/02_image_approximation.py
 examples/07_evonet/03_structural_xor.py
-examples/07_evonet/04_recurrent_bitseq.py
+examples/07_evonet/04_recurrent_bit_prediction.py
 examples/07_evonet/resize_all_images.py
 tests/test_benchmarks.py
 tests/test_config_loader.py

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/examples/02_strategies/01_step_by_step_evolution.py

@@ -74,14 +74,14 @@ pop = Pop(config_path="01_step_by_step_evolution.yaml", fitness_function=my_fitn
 pop.evaluate_fitness()
 print_indivs("0) Evaluate parents :", pop.indivs)
 
-# Step 1) Update per-generation parameters (mutation/crossover controls)
-pop.update_parameters()
-print_indivs("1) Update parameters: ", pop.indivs)
-
-# Step 2) Produce offspring by cloning
+# Step 1) Produce offspring by cloning
 offspring = generate_cloned_offspring(pop.indivs, pop.offspring_pool_size)
 print_indivs("2) Reproduction (clone parents -> offspring): ", offspring)
 
+# Step 2) Update per-generation parameters (mutation/crossover controls)
+pop.update_parameters(offspring)
+print_indivs("1) Update parameters: ", pop.indivs)
+
 # Step 3) Crossover pairs (in-place)
 crossover_offspring(pop, offspring)
 print_indivs("3) Crossover: ", offspring)

evolib-0.2.0b2.dev5/examples/07_evonet/04_recurrent_bit_prediction.py

@@ -0,0 +1,107 @@
+"""
+Example: Recurrent Bit Sequence Prediction (with LFSR)
+
+This example demonstrates how an EvoNet with recurrent connections
+can be evolved to predict the next bit in a pseudo-random binary sequence
+generated by a 5-bit LFSR.
+
+Key details:
+- The sequence has period length 31 (maximal length LFSR).
+- The sequence is repeated twice: first pass = warm-up, second pass = evaluation.
+- Fitness combines mean squared error with a penalty for misclassification.
+- Visualization shows input, target, and predictions during the evaluation phase.
+"""
+
+from evolib import Individual, Population, plot_bit_prediction
+from evolib.utils.benchmarks import lfsr_sequence
+
+FRAME_FOLDER = "04_frames"
+CONFIG_FILE = "configs/04_recurrent_bit_prediction.yaml"
+
+SEQ_LENGTH = 31
+warmup_steps = SEQ_LENGTH
+
+input_seq = lfsr_sequence(SEQ_LENGTH) * 2
+target_seq = input_seq[1:] + [input_seq[0]]
+
+
+def fitness_bitseq(indiv: Individual) -> None:
+    """
+    Evaluate how well the EvoNet predicts the next bit in a fixed sequence.
+
+    Additionally logs classification accuracy in indiv.extra_metrics.
+    Note: Fitness combines MSE with penalty term (1-accuracy)/4
+    """
+    net = indiv.para["brain"].net
+    net.reset(full=True)
+
+    total_error = 0.0
+    correct = 0
+    count = 0
+
+    for t in range(len(input_seq)):
+        output = net.calc([input_seq[t]])[0]
+        if t >= warmup_steps:
+            target = target_seq[t]
+            # --- MSE ---
+            error = output - target
+            total_error += error**2
+
+            # --- Accuracy ---
+            pred_bit = 1 if output > 0.5 else 0
+            if pred_bit == target:
+                correct += 1
+            count += 1
+
+    mse = total_error / count
+    acc = correct / count if count > 0 else 0.0
+
+    # Log extra metrics
+    indiv.extra_metrics = {"accuracy": acc, "mse": mse}
+
+    indiv.fitness = mse + (1 - acc) / 4
+
+
+def save_plot(pop: Population) -> None:
+    best = pop.best()
+    net = best.para["brain"].net
+    net.reset(full=True)
+
+    # Warmup
+    for bit in input_seq[:SEQ_LENGTH]:
+        net.calc([bit])
+
+    # Prediction
+    y_preds = [net.calc([bit])[0] for bit in input_seq[SEQ_LENGTH:]]
+
+    true_bits = target_seq[SEQ_LENGTH:]
+    input_bits = input_seq[SEQ_LENGTH:]
+
+    acc = best.extra_metrics.get("accuracy", 0.0)
+    mse = best.extra_metrics.get("mse", best.fitness)
+
+    print(
+        f"[Gen {pop.generation_num}] best fitness={best.fitness:.5f}, "
+        f"acc={acc:.3%}, mse={mse:.5f}"
+    )
+
+    plot_bit_prediction(
+        true_bits=true_bits,
+        pred_values=y_preds,
+        input_bits=input_bits,
+        title=(
+            f"Bit Prediction (gen={pop.generation_num}, "
+            f"MSE={mse:.5f}, Acc={acc:.3%})"
+        ),
+        save_path=f"{FRAME_FOLDER}/gen_{pop.generation_num:03d}.png",
+    )
+
+
+if __name__ == "__main__":
+    pop = Population(CONFIG_FILE, fitness_function=fitness_bitseq)
+    pop.run(verbosity=0, on_generation_end=save_plot)
+
+    best = pop.best()
+    best.para["brain"].net.print_graph(
+        "04_recurrent_bit_prediction", fillcolors_on=True
+    )

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evolib"
-version = "0.2.0b2.dev4"
+version = "0.2.0b2.dev5"
 description = "A modular framework for evolutionary strategies and neuroevolution."
 authors = [
     { name = "EvoLib", email = "evolib@dismail.de" }

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev5}/tests/test_evonet_vector_io.py

@@ -17,21 +17,21 @@ def _build_net_2_3_1(para: EvoNet) -> None:
         role=NeuronRole.INPUT,
         activation="linear",
         count=2,
-        connect_layer=False,
+        connection_init="none",
     )
     para.net.add_neuron(
         layer_idx=1,
         role=NeuronRole.HIDDEN,
         activation="linear",
         count=3,
-        connect_layer=True,
+        connection_init="random",
     )
     para.net.add_neuron(
         layer_idx=2,
         role=NeuronRole.OUTPUT,
         activation="linear",
         count=1,
-        connect_layer=True,
+        connection_init="random",
     )
 
 
@@ -44,14 +44,14 @@ def _build_net_1_1(para: EvoNet) -> None:
         role=NeuronRole.INPUT,
         activation="linear",
         count=1,
-        connect_layer=False,
+        connection_init="none",
     )
     para.net.add_neuron(
         layer_idx=1,
         role=NeuronRole.OUTPUT,
         activation="linear",
         count=1,
-        connect_layer=True,
+        connection_init="random",
     )