evolib 0.2.0b2.dev3__tar.gz → 0.2.0b2.dev5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b2.dev3
+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.dev3 → evolib-0.2.0b2.dev5}/evolib/core/individual.py

@@ -21,15 +21,17 @@ Classes:
 
 from copy import deepcopy
 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.
@@ -60,6 +62,7 @@ class Indiv:
     extra_metrics: dict[str, float]
 
     __slots__ = (
+        "id",
         "para",
         "fitness",
         "is_evaluated",
@@ -72,7 +75,8 @@ class Indiv:
     )
 
     def __init__(self, para: Any = None):
-        self.para = para
+        self.id: str = str(uuid4())
+        self.para = para if para is not None else ParaDummy()
         self.fitness = None
         self.is_evaluated = False
         self.age = 0
@@ -160,14 +164,43 @@ class Indiv:
         """Return True if the individual is an offspring."""
         return self.origin == Origin.OFFSPRING
 
-    def copy(self) -> "Indiv":
+    def copy(
+        self,
+        *,
+        reset_id: bool = True,
+        reset_fitness: bool = False,
+        reset_age: bool = False,
+        reset_evaluation: bool = False,
+        reset_origin: bool = False,
+    ) -> "Indiv":
         """
-        Create a copy of the individual.
+        Create a copy of the individual, with optional resets.
 
-        This method can be overridden in subclasses to implement
-        optimized or custom copy behavior.
+        Args:
+            reset_id (bool): If True (default), assign a new unique ID to the copy.
+            reset_fitness (bool): If True, set fitness to None in the copy.
+            reset_age (bool): If True, set age to 0 in the copy.
+            reset_evaluation (bool): If True, set is_evaluated = False in the copy.
+            reset_origin (bool): If True, set origin = Origin.OFFSPRING
+                                 and parent_idx = None in the copy.
 
         Returns:
-            Indiv: A copy of this individual.
+            Indiv: A (possibly reset) copy of this individual.
         """
-        return deepcopy(self)
+        new_indiv: Indiv = deepcopy(self)
+
+        if reset_id:
+            new_indiv.id = str(uuid4())
+        if reset_fitness:
+            new_indiv.fitness = None
+        if reset_age:
+            new_indiv.age = 0
+        if reset_evaluation:
+            new_indiv.is_evaluated = False
+        if reset_origin:
+            from evolib.interfaces.enums import Origin
+
+            new_indiv.origin = Origin.OFFSPRING
+            new_indiv.parent_idx = None
+
+        return new_indiv

{evolib-0.2.0b2.dev3 → evolib-0.2.0b2.dev5}/evolib/core/population.py

@@ -208,6 +208,10 @@ class Pop:
             para = init_fn(self)
             self.add_indiv(Indiv(para=para))
 
+        # initialize adaptive parameters for initial parents
+        if self.indivs:
+            self.update_parameters(self.indivs)
+
     def set_fitness_function(self, func: FitnessFunction) -> None:
         """
         Sets the fitness function to be used for evaluating individuals.
@@ -567,7 +571,7 @@ class Pop:
 
         self.history_logger.reset()
 
-    def update_parameters(self) -> None:
+    def update_parameters(self, indivs: list[Indiv]) -> None:
         """
         Update all strategy-dependent parameters for the current generation.
 
@@ -577,43 +581,54 @@ class Pop:
             ValueError or AttributeError if the population or its individuals
             are invalid.
         """
-        self.update_mutation_parameters()
-        self.update_crossover_parameters()
+        self.update_mutation_parameters(indivs)
+        self.update_crossover_parameters(indivs)
 
-    def update_mutation_parameters(self) -> None:
+    def update_mutation_parameters(self, indivs: list[Indiv]) -> None:
         """
-        Triggers per-generation mutation parameter updates for all individuals in the
-        population via their `para` objects.
+        Update mutation-related parameters for a given set of individuals via their
+        `para` objects.
 
-        This ensures that all individuals – including parents – are updated consistently
-        based on current generation number.
+        Typical usage:
+            - During population initialization: called once on all parents to ensure
+              they start with valid adaptive parameters.
+            - During evolution: called on offspring *before* mutation, so that new
+              individuals use up-to-date parameters (e.g. annealing schedules).
 
-        Uses a polymorphic call to `para.update_mutation_parameters()`, preserving
-        encapsulation.
+        Notes:
+            - Parents are not updated in every generation. They keep the parameters
+              assigned at initialization, ensuring selection acts on stable values.
+            - Offspring are updated once per generation, prior to mutation.
         """
-        for indiv in self.indivs:
+
+        for indiv in indivs:
+            assert indiv.para is not None
             indiv.para.update_mutation_parameters(
                 self.generation_num, self.max_generations, self.diversity_ema
             )
 
-    def update_crossover_parameters(self) -> None:
+    def update_crossover_parameters(self, indivs: list[Indiv]) -> None:
         """
-        Triggers per-generation update of crossover parameters for all individuals.
+        Update crossover-related parameters for a given set of individuals.
 
-        Applies strategy-dependent crossover control (e.g. exponential decay or
-        adaptive global), using generation number and population diversity.
+        Typical usage:
+            - During population initialization: called once on all parents to ensure
+              they start with valid crossover parameters.
+            - During evolution: called on offspring *before* crossover, so that new
+              individuals use up-to-date parameters (e.g. annealing schedules or
+              adaptive rates).
 
-        Raises:
-            ValueError: If population is uninitialized or empty.
-            AttributeError: If an individual lacks a valid 'para' object with method
-                            'update_crossover_parameters'.
+        Notes:
+            - Parents are not updated in every generation. They keep the parameters
+              assigned at initialization, ensuring selection acts on stable values.
+            - Offspring are updated once per generation, prior to crossover.
         """
-        if not self.indivs:
+        if not indivs:
             raise ValueError(
                 "Population is empty – cannot update crossover parameters."
             )
 
-        for indiv in self.indivs:
+        for indiv in indivs:
             if not hasattr(indiv, "para") or not hasattr(
                 indiv.para, "update_crossover_parameters"
             ):
@@ -622,6 +637,7 @@ class Pop:
                     "with 'update_crossover_parameters' method."
                 )
 
+            assert indiv.para is not None
             indiv.para.update_crossover_parameters(
                 self.generation_num,
                 self.max_generations,

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.dev3 → 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.dev5/evolib/interfaces/enum_helpers.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: MIT
+
+from typing import Optional, Set
+
+from evonet.enums import RecurrentKind
+
+
+def resolve_recurrent_kinds(preset: Optional[str]) -> Set[RecurrentKind]:
+    """
+    Map a preset string to the corresponding set of recurrent connection types.
+
+    Parameters
+    ----------
+    preset : Optional[str]
+        One of: "none", "direct", "local", "all", or None.
+
+    Returns
+    -------
+    Set[RecurrentKind]
+        A set of recurrent kinds to use.
+    """
+    if preset is None or preset == "none":
+        return set()
+    elif preset == "direct":
+        return {RecurrentKind.DIRECT}
+    elif preset == "local":
+        return {RecurrentKind.DIRECT, RecurrentKind.LATERAL}
+    elif preset == "all":
+        return {RecurrentKind.DIRECT, RecurrentKind.LATERAL, RecurrentKind.INDIRECT}
+    else:
+        raise ValueError(f"Unknown recurrent preset: {preset}")

{evolib-0.2.0b2.dev3 → 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.dev3 → evolib-0.2.0b2.dev5}/evolib/operators/evonet_structural_mutation.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 from evonet.core import Nnet
-from evonet.enums import NeuronRole, RecurrentKind
+from evonet.enums import NeuronRole
 from evonet.mutation import (
     add_random_connection,
     add_random_neuron,
@@ -12,19 +12,7 @@ from evonet.mutation import (
 )
 
 from evolib.config.base_component_config import StructuralMutationConfig
-
-
-def resolve_recurrent_kinds(preset: str | None) -> set[RecurrentKind]:
-    if preset == "none" or preset is None:
-        return set()
-    elif preset == "direct":
-        return {RecurrentKind.DIRECT}
-    elif preset == "local":
-        return {RecurrentKind.DIRECT, RecurrentKind.LATERAL}
-    elif preset == "all":
-        return {RecurrentKind.DIRECT, RecurrentKind.LATERAL, RecurrentKind.INDIRECT}
-    else:
-        raise ValueError(f"Unknown recurrent preset: {preset}")
+from evolib.interfaces.enum_helpers import resolve_recurrent_kinds
 
 
 def mutate_structure(net: Nnet, cfg: StructuralMutationConfig) -> None:

{evolib-0.2.0b2.dev3 → evolib-0.2.0b2.dev5}/evolib/operators/reproduction.py

@@ -4,9 +4,6 @@ from typing import Any, List
 
 import numpy as np
 
-from evolib.interfaces.enums import Origin
-from evolib.utils.copy_indiv import copy_indiv
-
 
 def generate_cloned_offspring(parents: List[Any], lambda_: int) -> List[Any]:
     """
@@ -37,11 +34,13 @@ def generate_cloned_offspring(parents: List[Any], lambda_: int) -> List[Any]:
 
     for idx in parent_indices:
         parent = parents[idx]
-        child = copy_indiv(parent)
-        child.age = 0
-        child.fitness = None
-        child.is_evaluated = False
-        child.origin = Origin.OFFSPRING
+        child = parent.copy(
+            reset_id=True,
+            reset_fitness=True,
+            reset_age=True,
+            reset_evaluation=True,
+            reset_origin=True,
+        )
         child.parent_idx = idx
         offspring.append(child)
 

{evolib-0.2.0b2.dev3 → evolib-0.2.0b2.dev5}/evolib/operators/selection.py

@@ -12,10 +12,9 @@ Included methods:
 - Truncation Selection
 
 All methods operate on a population of individuals with assigned fitness values and
-return deep copies of selected parents.
+return copies of selected parents.
 """
 
-import copy
 import random
 from typing import TYPE_CHECKING, Any, List, Optional
 
@@ -124,7 +123,7 @@ def selection_tournament(
             )
 
         # Kopie des besten Individuums hinzufuegen
-        selected_parents.append(copy.deepcopy(pop.indivs[best_idx]))
+        selected_parents.append(pop.indivs[best_idx].copy())
 
         # Entfernen, falls gewuenscht
         if remove_selected:
@@ -159,7 +158,7 @@ def selection_rank_based(
         Default: False (minimization).
 
     Returns:
-        List[Any]: List of selected individuals (deep copies).
+        List[Any]: List of selected individuals (copies).
 
     Raises:
         ValueError: If parameters are invalid (e.g., empty population,
@@ -181,8 +180,6 @@ def selection_rank_based(
     if mode == "exponential" and exp_base is None:
         raise ValueError("exp_base must be set when using exponential rank selection.")
 
-    exp_base = 1.0
-
     fitnesses = [indiv.fitness for indiv in pop.indivs]
     if any(f is None or np.isnan(f) for f in fitnesses):
         raise TypeError("All fitness values must be valid (not None or NaN)")
@@ -222,7 +219,7 @@ def selection_rank_based(
         # Select an individual based on rank probability
         list_index = np.random.choice(population_size, p=probabilities)
         selected_idx = available_indices[list_index]
-        selected_parents.append(copy.deepcopy(pop.indivs[selected_idx]))
+        selected_parents.append(pop.indivs[selected_idx].copy())
 
         # Optionally remove selected individual
         if remove_selected:
@@ -260,13 +257,13 @@ def selection_random(pop: "Pop", remove_selected: bool = False) -> List[Indiv]:
 
         # Randomly select individual from the population
         selected_parent = random.choice(available_indivs)
-        parent = copy.deepcopy(selected_parent)
+        parent = selected_parent.copy()
 
         # Append the best individual to offspring
         selected_parents.append(parent)
 
         if remove_selected:
-            available_indivs.remove(parent)
+            available_indivs.remove(selected_parent)
 
     return selected_parents
 
@@ -282,7 +279,7 @@ def selection_roulette(
         fitness_maximization (bool): If True, higher fitness is better.
 
     Returns:
-        List[Any]: List of selected individuals (deep copies).
+        List[Any]: List of selected individuals (copies).
     """
     if not pop.indivs:
         raise ValueError("Population is empty")
@@ -302,7 +299,7 @@ def selection_roulette(
     probabilities = fitnesses / total_fitness
     indices = np.random.choice(len(pop.indivs), size=num_parents, p=probabilities)
 
-    return [copy.deepcopy(pop.indivs[i]) for i in indices]
+    return [pop.indivs[i].copy() for i in indices]
 
 
 def selection_sus(
@@ -316,7 +313,7 @@ def selection_sus(
         fitness_maximization (bool): If True, higher fitness is better.
 
     Returns:
-        List[Any]: Selected individuals (deep copies).
+        List[Any]: Selected individuals (copies).
     """
     if not pop.indivs:
         raise ValueError("Population is empty")
@@ -345,7 +342,7 @@ def selection_sus(
     for p in pointers:
         while p > cumulative[i]:
             i += 1
-        selected.append(copy.deepcopy(pop.indivs[i]))
+        selected.append(pop.indivs[i].copy())
 
     return selected
 
@@ -365,7 +362,7 @@ def selection_boltzmann(
         fitness_maximization (bool): If True, higher fitness is better.
 
     Returns:
-        List[Any]: Selected individuals (deep copies).
+        List[Any]: Selected individuals (copies).
     """
     if not pop.indivs:
         raise ValueError("Population is empty")
@@ -388,7 +385,7 @@ def selection_boltzmann(
     probabilities = exp_values / np.sum(exp_values)
 
     indices = np.random.choice(len(pop.indivs), size=num_parents, p=probabilities)
-    return [copy.deepcopy(pop.indivs[i]) for i in indices]
+    return [pop.indivs[i].copy() for i in indices]
 
 
 def selection_truncation(
@@ -402,7 +399,7 @@ def selection_truncation(
         fitness_maximization (bool): If True, selects best fitness; else lowest.
 
     Returns:
-        List[Any]: Selected individuals (deep copies).
+        List[Any]: Selected individuals (copies).
     """
 
     if not pop.indivs:
@@ -419,4 +416,4 @@ def selection_truncation(
         sorted_indices = sorted_indices[::-1]
 
     selected_indices = sorted_indices[:num_parents]
-    return [copy.deepcopy(pop.indivs[i]) for i in selected_indices]
+    return [pop.indivs[i].copy() for i in selected_indices]