evolib 0.2.0b2.dev4__tar.gz → 0.2.0b2.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b2.dev4
+Version: 0.2.0b2.dev6
 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.dev6}/evolib/api.py

@@ -15,9 +15,11 @@ from evolib.utils.benchmarks import (
     ackley,
     ackley_2d,
     ackley_3d,
+    generate_timeseries,
     griewank,
     griewank_2d,
     griewank_3d,
+    lfsr_sequence,
     rastrigin,
     rastrigin_2d,
     rastrigin_3d,
@@ -90,6 +92,8 @@ __all__ = [
     "sphere_3d",
     "rosenbrock_3d",
     "schwefel_3d",
+    "lfsr_sequence",
+    "generate_timeseries",
     "save_checkpoint",
     "resume_from_checkpoint",
     "save_best_indiv",

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev6}/evolib/config/schema.py

@@ -88,6 +88,30 @@ class StoppingCriteria(BaseModel):
     )
 
 
+class ParallelConfig(BaseModel):
+    """
+    Optional parallelization backend.
+
+    Controls whether fitness evaluation is run sequentially or distributed
+    (currently only Ray is supported).
+    """
+
+    backend: str = Field(
+        default="none",
+        description="Parallel backend to use: 'none' (default) or 'ray'.",
+    )
+    num_cpus: Optional[int] = Field(
+        default=None,
+        description="Number of CPUs to allocate (Ray only). "
+                    "If None, Ray chooses automatically.",
+    )
+    address: Optional[str] = Field(
+        default=None,
+        description="Ray cluster address (e.g. 'auto' or '127.0.0.1:6379'). "
+                    "If None, starts a local Ray instance.",
+    )
+
+
 class FullConfig(BaseModel):
     """
     Main configuration model for an evolutionary run.
@@ -140,6 +164,12 @@ class FullConfig(BaseModel):
     replacement: ReplacementConfig | None = Field(
         default=None, description="Survivor selection (replacement) configuration."
     )
+    
+    # Optional parallelization backend
+    parallel: Optional[ParallelConfig] = Field(
+        default=None,
+        description="Optional parallelization backend configuration."
+    )
 
     @model_validator(mode="before")
     @classmethod

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev6}/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.dev4 → evolib-0.2.0b2.dev6}/evolib/core/population.py

@@ -51,6 +51,8 @@ from evolib.utils.config_loader import load_config
 from evolib.utils.history_logger import HistoryLogger
 from evolib.utils.random import set_random_seed
 
+from evolib.utils.parallel import map_fitness
+
 
 class Pop:
     """Represents a population for evolutionary optimization, including configuration,
@@ -128,6 +130,16 @@ class Pop:
             self._replacement_registry = {}
             self._replacement_fn = None
 
+        # Parallel backend
+        if cfg.parallel:
+            self.parallel_backend = cfg.parallel.backend
+            self.parallel_num_cpus = cfg.parallel.num_cpus
+            self.parallel_address = cfg.parallel.address
+        else:
+            self.parallel_backend = None
+            self.parallel_num_cpus = None
+            self.parallel_address = None
+
         # Statistics
         self.history_logger = HistoryLogger(
             columns=[
@@ -242,21 +254,27 @@ class Pop:
         """Evaluate the fitness function for all individuals in the population."""
         if self.fitness_function is None:
             raise ValueError("No fitness function has been set.")
-        for indiv in self.indivs:
-            result = self.fitness_function(indiv)
-            if result is not None:
-                indiv.fitness = float(result)
-            indiv.is_evaluated = True
+
+        map_fitness(
+            self.indivs,
+            self.fitness_function,
+            backend=self.parallel_backend,
+            num_cpus=self.parallel_num_cpus,
+            address=self.parallel_address,
+        )
 
     def evaluate_indivs(self, indivs: list[Indiv]) -> None:
         """Evaluate fitness for a custom list of individuals."""
         if self.fitness_function is None:
             raise ValueError("No fitness function has been set.")
-        for indiv in indivs:
-            result = self.fitness_function(indiv)
-            if result is not None:
-                indiv.fitness = float(result)
-            indiv.is_evaluated = True
+
+        map_fitness(
+            indivs,
+            self.fitness_function,
+            backend=self.parallel_backend,
+            num_cpus=self.parallel_num_cpus,
+            address=self.parallel_address,
+        )
 
     def get_elites(self) -> list[Indiv]:
         """Return a list of elite individuals and set their is_elite flag."""
@@ -408,14 +426,14 @@ class Pop:
 
         self.indivs.sort(key=lambda indivs: indivs.fitness, reverse=reverse)
 
-    def best(self, sort: bool = False) -> Indiv:
+    def best(self, sort: bool = True) -> Indiv:
         """
         Return the best individual (lowest fitness).
 
         Args:
             sort (bool): If True, sort the population before returning the best.
                          If False, return first individual as-is.
-                         Default: False.
+                         Default: True.
         """
 
         if not self.indivs:

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

@@ -0,0 +1,193 @@
+# 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 ConnectionType, 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
+
+
+def initializer_identity_evonet(config: FullConfig, module: str) -> EvoNet:
+    """
+    Initialize EvoNet with damped self-recurrence and zeroed weights elsewhere.
+
+    - All feedforward weights are near-zero
+    - Self-recurrent connections get weight ~0.8 (memory)
+    - Biases are randomized slightly to break symmetry
+
+    This initializer encourages stable internal state retention from the start,
+    making recurrent behavior immediately available to evolution.
+
+    Args:
+        config (FullConfig): Full experiment configuration
+        module (str): Name of the EvoNet module in the config
+
+    Returns:
+        EvoNet: Initialized network with identity-style dynamics
+    """
+
+    SELF_LOOP_WEIGHT = 0.8
+    ALPHA = 0.01
+
+    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))
+
+    for neuron in para.net.get_all_neurons():
+        # Small random bias to break symmetry
+        neuron.bias = np.random.uniform(-ALPHA, ALPHA)
+        for connection in neuron.outgoing:
+            # Damped self-recurrence: acts like memory cell
+            if (
+                connection.type == ConnectionType.RECURRENT
+                and connection.source.id == connection.target.id
+            ):
+                connection.weight = SELF_LOOP_WEIGHT
+
+            # Small random feedforward weight to allow weak stimulus flow
+            if connection.type == ConnectionType.STANDARD:
+                connection.weight = np.random.uniform(-ALPHA, ALPHA)
+
+    return para

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

@@ -16,7 +16,12 @@ 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_identity_evonet,
+    initializer_normal_evonet,
+    initializer_random_evonet,
+    initializer_zero_evonet,
+)
 
 # NetVector-based initializer
 from evolib.initializers.net_initializers import initializer_normal_net
@@ -45,6 +50,9 @@ 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,
+    "identity_evonet": initializer_identity_evonet,
 }
 
 

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev6}/evolib/io/checkpoint.py

@@ -14,6 +14,7 @@ All files are stored in the 'checkpoints/' directory by default.
 from pathlib import Path
 from typing import Any, Optional, cast
 
+from evolib.config.schema import FullConfig
 from evolib.core.individual import Indiv
 from evolib.core.population import Pop
 from evolib.initializers.registry import build_composite_initializer
@@ -24,6 +25,8 @@ from evolib.io.serialization import (
     save_indiv,
     save_population_pickle,
 )
+from evolib.utils.config_loader import load_config
+from evolib.utils.random import set_random_seed
 
 # Internal checkpoint directory
 _CHECKDIR = Path("checkpoints")
@@ -116,8 +119,13 @@ def resume_or_create(
     )
 
     if pop is not None:
+        print(f"[Resume] Loaded checkpoint for run_name={run_name}")
+        cfg: FullConfig = load_config(config_path)
+        random_seed = cfg.random_seed
+        set_random_seed(random_seed)
         return pop
-
+    
+    print(f"[Create] New population for run_name={run_name}")
     return Pop(config_path=config_path, fitness_function=fitness_fn)
 
 

{evolib-0.2.0b2.dev4 → evolib-0.2.0b2.dev6}/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.dev6/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.dev6}/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)