evolib 0.2.0b2.dev3__tar.gz → 0.2.0b2.dev4__tar.gz

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

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

@@ -21,6 +21,7 @@ Classes:
 
 from copy import deepcopy
 from typing import Any, Dict, Optional
+from uuid import uuid4
 
 from evolib.interfaces.enums import Origin
 
@@ -60,6 +61,7 @@ class Indiv:
     extra_metrics: dict[str, float]
 
     __slots__ = (
+        "id",
         "para",
         "fitness",
         "is_evaluated",
@@ -71,7 +73,8 @@ class Indiv:
         "is_elite",
     )
 
-    def __init__(self, para: Any = None):
+    def __init__(self, para: Any | None = None):
+        self.id: str = str(uuid4())
         self.para = para
         self.fitness = None
         self.is_evaluated = False
@@ -160,14 +163,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.dev4}/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.dev4/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.dev4}/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.dev4}/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.dev4}/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]

{evolib-0.2.0b2.dev3 → evolib-0.2.0b2.dev4}/evolib/operators/strategy.py

@@ -47,12 +47,12 @@ def evolve_mu_plus_lambda(pop: "Pop") -> None:
     # Age all current individuals
     pop.age_indivs()
 
-    # Update mutation/crossover parameters
-    pop.update_parameters()
-
     # CREATE OFFSPRING
     offspring = generate_cloned_offspring(pop.indivs, pop.offspring_pool_size)
 
+    # Update mutation/crossover parameters
+    pop.update_parameters(offspring)
+
     # Crossover
     crossover_offspring(pop, offspring)
 
@@ -90,12 +90,12 @@ def evolve_mu_comma_lambda(pop: "Pop") -> None:
 
     pop.evaluate_fitness()
 
-    # Update mutation/crossover parameters
-    pop.update_parameters()
-
     # CREATE OFFSPRING
     offspring = generate_cloned_offspring(pop.indivs, pop.offspring_pool_size)
 
+    # Update mutation/crossover parameters
+    pop.update_parameters(offspring)
+
     # Crossover
     crossover_offspring(pop, offspring)
 
@@ -164,7 +164,7 @@ def evolve_steady_state(pop: "Pop") -> None:
     offspring = generate_cloned_offspring(parents, pop.lambda_)
 
     # Update mutation/crossover parameters
-    pop.update_parameters()
+    pop.update_parameters(offspring)
 
     # Crossover
     crossover_offspring(pop, offspring)
@@ -226,12 +226,12 @@ def evolve_flexible(pop: "Pop") -> None:
     # Reproduction
     offspring = generate_cloned_offspring(parents, pop.lambda_)
 
+    # Mutation & Crossover Parameters
+    pop.update_parameters(offspring)
+
     # Crossover
     crossover_offspring(pop, offspring)
 
-    # Mutation & Crossover Parameters
-    pop.update_parameters()
-
     # Mutation
     mutate_offspring(pop, offspring)
 

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

@@ -17,12 +17,10 @@ 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,
-    resolve_recurrent_kinds,
-)
+from evolib.operators.evonet_structural_mutation import mutate_structure
 from evolib.operators.mutation import (
     adapt_mutation_probability_by_diversity,
     adapt_mutation_strength,
@@ -317,7 +315,8 @@ class EvoNet(ParaBase):
                 )
 
             # Perform adaptive update
-            ep.mutation_strength = adapt_mutation_strength(ep, self.weight_bounds)
+            bounds = (ep.min_mutation_strength, ep.max_mutation_strength)
+            ep.mutation_strength = adapt_mutation_strength(ep, bounds)
 
         # If Bias-Override exists
         if self.bias_evo_params is not None:
@@ -366,7 +365,10 @@ class EvoNet(ParaBase):
                     bep.mutation_strength = np.random.uniform(
                         bep.min_mutation_strength, bep.max_mutation_strength
                     )
-                bep.mutation_strength = adapt_mutation_strength(bep, self.bias_bounds)
+
+                # Perform adaptive update
+                bounds = (bep.min_mutation_strength, bep.max_mutation_strength)
+                bep.mutation_strength = adapt_mutation_strength(bep, bounds)
 
     def get_vector(self) -> np.ndarray:
         """Return a flat vector containing all weights and biases."""

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b2.dev3
+Version: 0.2.0b2.dev4
 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.dev4}/evolib.egg-info/SOURCES.txt

@@ -280,6 +280,7 @@ evolib/initializers/.mypy_cache/3.12/zipfile/__init__.py
 evolib/initializers/.mypy_cache/3.12/zipfile/_path/__init__.py
 evolib/initializers/__pycache__/__init__.py
 evolib/interfaces/__init__.py
+evolib/interfaces/enum_helpers.py
 evolib/interfaces/enums.py
 evolib/interfaces/structs.py
 evolib/interfaces/types.py
@@ -403,7 +404,6 @@ evolib/utils/README.md
 evolib/utils/__init__.py
 evolib/utils/benchmarks.py
 evolib/utils/config_loader.py
-evolib/utils/copy_indiv.py
 evolib/utils/fitness.py
 evolib/utils/history_logger.py
 evolib/utils/loss_functions.py

{evolib-0.2.0b2.dev3 → evolib-0.2.0b2.dev4}/examples/07_evonet/04_recurrent_bitseq.py

@@ -3,9 +3,12 @@ Example: Recurrent Bit Sequence Prediction
 
 This example demonstrates how an EvoNet with recurrent connections
 can be evolved to predict the next bit in a fixed binary sequence.
-A warm-up phase is used to let the network state settle before
-fitness is measured. Visualization combines a raster plot of
-input/target/prediction bits with a line plot of prediction quality.
+
+Key details:
+- The bit sequence is repeated twice.
+- The first pass is used as a warm-up so the recurrent state can settle.
+- Fitness and accuracy are evaluated only on the second pass.
+- Visualization shows input, target, and predictions for the evaluated phase.
 """
 
 from evolib import Population, Individual, plot_bit_prediction
@@ -14,8 +17,8 @@ from evolib.representation.evonet import EvoNet
 FRAME_FOLDER = "04_frames"
 CONFIG_FILE = "configs/04_recurrent_bitseq.yaml"
 
-#input_seq = [0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1] * 4
-#target_seq = [1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0] * 4
+SEQ_LENGTH = 31
+warmup_steps = SEQ_LENGTH
 
 def lfsr_sequence(length: int, seed: int = 0b10011, taps=(5, 2)) -> list[int]:
     """
@@ -45,55 +48,93 @@ def lfsr_sequence(length: int, seed: int = 0b10011, taps=(5, 2)) -> list[int]:
         bit = state & 1
         seq.append(bit)
         # compute feedback from taps
-        fb = 0
+        fb = 1
         for t in taps:
             fb ^= (state >> (t - 1)) & 1
         state = (state >> 1) | (fb << (n - 1))
     return seq
 
 
-input_seq = lfsr_sequence(44)
-target_seq = input_seq[1:] + [input_seq[0]]  # nächstes Bit als Ziel
-warmup_steps = 5
-
-
 def fitness_bitseq(indiv: Individual) -> float:
     """
     Evaluate how well the EvoNet predicts the next bit in a fixed sequence.
-    Errors from the first `warmup_steps` are ignored to allow network state to settle.
+    Returns mean squared error (to minimize).
+    Additionally logs classification accuracy in indiv.extra_metrics.
     """
     net: EvoNet = 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:
-            error = output - target_seq[t]
+            target = target_seq[t]
+            # --- MSE ---
+            error = output - target
             total_error += error**2
 
-    return total_error / (len(input_seq) - warmup_steps)
+            # --- 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}
+
+    return mse + (1-acc) / 4
 
 
 def save_plot(pop: Population) -> None:
-    """
-    Save visualization of the best individual's predictions
-    at the current generation.
-    """
     best = pop.best()
-    y_preds = [best.para["brain"].net.calc([bit])[0] for bit in input_seq]
+    net = best.para["brain"].net
+    net.reset(full=True)
+
+    print(
+            f"id: {best.id[:6]} "
+          f"ms: {best.para["brain"].evo_params.mutation_strength} "
+          f"mse: {best.extra_metrics.get("mse", best.fitness):.5} "
+          f"acc: {best.extra_metrics.get("accuracy", 0.0):.3%}")
+
+    # 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)
 
     plot_bit_prediction(
-        true_bits=target_seq,
+        true_bits=true_bits,
         pred_values=y_preds,
-        input_bits=input_seq,
-        title=f"Bit Prediction (gen={pop.generation_num}, MSE={best.fitness:.4f})",
+        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",
     )
-    
+
+    best = pop.best()
     best.para["brain"].net.print_graph("test.png",fillcolors_on=True)
 
 
+input_seq = lfsr_sequence(SEQ_LENGTH) * 2
+target_seq = input_seq[1:] + [input_seq[0]]
+
+
 if __name__ == "__main__":
     pop = Population(CONFIG_FILE, fitness_function=fitness_bitseq)
     pop.run(verbosity=1, on_generation_end=save_plot)

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

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