evolib 0.2.0b2.dev5__tar.gz → 0.2.0b2.dev7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b2.dev5
+Version: 0.2.0b2.dev7
 Summary: A modular framework for evolutionary strategies and neuroevolution.
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License
@@ -76,6 +76,7 @@ EvoLib is a lightweight and transparent framework for evolutionary computation,
 - **Modularity**: mutation, selection, crossover, and parameter representations can be freely combined.  
 - **Educational value**: examples and a clean API make it practical for illustrating evolutionary concepts.  
 - **Neuroevolution support**: structural mutations (adding/removing neurons and connections) and evolvable networks via EvoNet.  
+- **Parallel evaluation (optional)**: basic support for [Ray](https://www.ray.io/) to speed up fitness evaluations.  
 - **Type-checked**: PEP8 compliant, and consistent code style.  
 
 
@@ -251,10 +252,9 @@ For deeper exploration, see the [full examples directory](examples/)
 - [X] Composite Parameters (multi-module individuals)
 - [X] Neuroevolution
 - [X] Topological Evolution (neurons, edges)
-- [ ] Co-Evolution & Speciation Support
+- [X] Ray Support for Parallel Evaluation (early prototypes)
 - [ ] Advanced Visualization
 - [ ] Game Environment Integration (pygame, PettingZoo - early prototypes)
-- [ ] Ray Support for Parallel Evaluation (early prototypes)
 
 
 ---

{evolib-0.2.0b2.dev5 → evolib-0.2.0b2.dev7}/README.md

@@ -20,6 +20,7 @@ EvoLib is a lightweight and transparent framework for evolutionary computation,
 - **Modularity**: mutation, selection, crossover, and parameter representations can be freely combined.  
 - **Educational value**: examples and a clean API make it practical for illustrating evolutionary concepts.  
 - **Neuroevolution support**: structural mutations (adding/removing neurons and connections) and evolvable networks via EvoNet.  
+- **Parallel evaluation (optional)**: basic support for [Ray](https://www.ray.io/) to speed up fitness evaluations.  
 - **Type-checked**: PEP8 compliant, and consistent code style.  
 
 
@@ -195,10 +196,9 @@ For deeper exploration, see the [full examples directory](examples/)
 - [X] Composite Parameters (multi-module individuals)
 - [X] Neuroevolution
 - [X] Topological Evolution (neurons, edges)
-- [ ] Co-Evolution & Speciation Support
+- [X] Ray Support for Parallel Evaluation (early prototypes)
 - [ ] Advanced Visualization
 - [ ] Game Environment Integration (pygame, PettingZoo - early prototypes)
-- [ ] Ray Support for Parallel Evaluation (early prototypes)
 
 
 ---

{evolib-0.2.0b2.dev5 → evolib-0.2.0b2.dev7}/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.dev5 → evolib-0.2.0b2.dev7}/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.
@@ -141,6 +165,11 @@ class FullConfig(BaseModel):
         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
     def resolve_component_configs(cls, data: dict[str, Any]) -> dict[str, Any]:

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

@@ -30,6 +30,9 @@ from evolib.representation.dummy import ParaDummy
 class Indiv:
     """Represents an individual in an evolutionary optimization algorithm."""
 
+    #: unique identifier (UUID)
+    id: str
+
     #: para (Any): Parameter values of the individual. Default: None.
     para: Any
 

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

@@ -49,6 +49,7 @@ from evolib.registry.selection_registry import build_selection_registry
 from evolib.registry.strategy_registry import strategy_registry
 from evolib.utils.config_loader import load_config
 from evolib.utils.history_logger import HistoryLogger
+from evolib.utils.parallel import map_fitness
 from evolib.utils.random import set_random_seed
 
 
@@ -128,6 +129,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 +253,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 +425,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.dev5 → evolib-0.2.0b2.dev7}/evolib/initializers/evonet_initializers.py

@@ -8,7 +8,7 @@ initialized EvoNet instance.
 
 import numpy as np
 from evonet.activation import random_function_name
-from evonet.enums import NeuronRole
+from evonet.enums import ConnectionType, NeuronRole
 
 from evolib.config.evonet_component_config import EvoNetComponentConfig
 from evolib.config.schema import FullConfig
@@ -142,3 +142,52 @@ def initializer_zero_evonet(config: FullConfig, module: str) -> EvoNet:
     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.dev5 → evolib-0.2.0b2.dev7}/evolib/initializers/registry.py

@@ -17,6 +17,7 @@ from evolib.config.schema import FullConfig
 
 # EvoNet-based initializer
 from evolib.initializers.evonet_initializers import (
+    initializer_identity_evonet,
     initializer_normal_evonet,
     initializer_random_evonet,
     initializer_zero_evonet,
@@ -51,6 +52,7 @@ INITIALIZER_REGISTRY: dict[str, InitializerFunction] = {
     "normal_evonet": initializer_normal_evonet,
     "random_evonet": initializer_random_evonet,
     "zero_evonet": initializer_zero_evonet,
+    "identity_evonet": initializer_identity_evonet,
 }
 
 

{evolib-0.2.0b2.dev5 → evolib-0.2.0b2.dev7}/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.dev5 → evolib-0.2.0b2.dev7}/evolib/utils/benchmarks.py

@@ -1,9 +1,107 @@
 # SPDX-License-Identifier: MIT
 """Common mathematical benchmark functions for optimization tasks."""
 
-from typing import Sequence
+from typing import Literal, Sequence
 
 import numpy as np
+from numpy.random import default_rng
+
+
+def generate_timeseries(
+    length: int,
+    normalize: bool = True,
+    pattern: Literal[
+        "default", "trend_switch", "parabolic", "zigzag", "shock"
+    ] = "default",
+    seed: int | None = None,
+) -> np.ndarray:
+    """
+    Generate synthetic time series data for evolution or forecasting. Uses local RNG to
+    avoid modifying global numpy random state.
+
+    Args:
+        length (int): Number of time steps.
+        normalize (bool): Whether to scale the output to [-1, 1].
+        pattern (str): Pattern to generate:
+            - "default": Trend + Sinus + Noise
+            - "trend_switch": Linear trend up, then down
+            - "parabolic": Smooth U-shaped curve (trend reversal)
+            - "zigzag": Periodic linear up/down pattern
+            - "shock": Trend followed by sharp reversal
+
+    Returns:
+        np.ndarray: The generated time series.
+    """
+
+    if seed is not None:
+        rng = default_rng(seed)
+    else:
+        # Use global np.random set via config
+        rng = np.random.default_rng(np.random.randint(0, 2**32 - 1))
+
+    t = np.arange(length)
+
+    if pattern == "shock":
+        # Random switch point + optional shock slope variation
+        switch_point = rng.integers(length // 3, 2 * length // 3)
+        slope_up = rng.uniform(0.005, 0.015)
+        slope_down = rng.uniform(-0.015, -0.005)
+        shock = np.where(
+            t < switch_point, slope_up * t, slope_down * (t - switch_point)
+        )
+        phase = rng.uniform(0, 2 * np.pi)
+        seasonal = np.sin(t * 0.1 + phase)
+        noise = rng.normal(0.05, 0.1, size=length)
+        series = shock + seasonal + noise
+
+    elif pattern == "parabolic":
+        # Random shift of parabola + curvature
+        center = rng.integers(length // 3, 2 * length // 3)
+        curvature = rng.uniform(0.0002, 0.0004)
+        trend = -curvature * (t - center) ** 2 + 1.0
+        phase = rng.uniform(0, 2 * np.pi)
+        seasonal = 0.5 * np.sin(t * 0.1 + phase)
+        noise = rng.normal(0, 0.02, size=length)
+        series = trend + seasonal + noise
+
+    elif pattern == "zigzag":
+        # Random zigzag period and slope
+        period = rng.integers(20, 60)
+        slope = rng.uniform(0.008, 0.015)
+        trend = slope * ((t // period) % 2 * 2 - 1) * (t % period)
+        phase = rng.uniform(0, 2 * np.pi)
+        seasonal = 0.3 * np.sin(t * 0.2 + phase)
+        noise = rng.normal(0, 0.03, size=length)
+        series = trend + seasonal + noise
+
+    elif pattern == "trend_switch":
+        # Random trend_switch position + strength
+        trend_switch_pos = rng.integers(length // 3, 2 * length // 3)
+        trend_switch_strength = rng.uniform(-0.04, -0.02)
+        trend = 0.01 * t
+        trend_switch = np.where(
+            t > trend_switch_pos, trend_switch_strength * (t - trend_switch_pos), 0.0
+        )
+        phase = rng.uniform(0, 2 * np.pi)
+        seasonal = 0.5 * np.sin(t * 0.1 + phase)
+        noise = rng.normal(0, 0.04, size=length)
+        series = trend + trend_switch + seasonal + noise
+
+    else:  # "default"
+        # Minor phase + trend variation
+        slope = rng.uniform(0.008, 0.012)
+        phase = rng.uniform(0, 2 * np.pi)
+        trend = slope * t
+        seasonal = np.sin(t * 0.1 + phase)
+        noise = rng.normal(0, 0.05, size=length)
+        series = trend + seasonal + noise
+
+    if normalize:  # Normalize to [-1, 1]
+        min_val = np.min(series)
+        max_val = np.max(series)
+        series = 2 * (series - min_val) / (max_val - min_val) - 1
+
+    return series
 
 
 def lfsr_sequence(

evolib-0.2.0b2.dev7/evolib/utils/parallel.py

@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: MIT
+"""
+Parallelization helpers for EvoLib.
+
+Currently supports optional Ray integration for fitness evaluation. Falls back to
+sequential evaluation if Ray is not available or not requested.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Optional
+
+from evolib.core.individual import Indiv
+
+if TYPE_CHECKING:
+    import ray
+else:
+    try:
+        import ray
+    except ImportError:
+        ray = None  # type: ignore[assignment]
+
+# Global flag to avoid repeated init/shutdown
+_ray_initialized = False
+
+
+def _ensure_ray_initialized(
+    num_cpus: Optional[int] = None, address: Optional[str] = None
+) -> None:
+    """Initialize Ray once with given resources."""
+    global _ray_initialized
+
+    if ray is None:
+        raise RuntimeError("Ray is not installed. Install with `pip install ray`.")
+
+    if not _ray_initialized:
+        init_kwargs: dict[str, Any] = {}
+        if num_cpus is not None:
+            init_kwargs["num_cpus"] = num_cpus
+        if address is not None:
+            init_kwargs["address"] = address
+        ray.init(**init_kwargs)
+        _ray_initialized = True
+
+
+def shutdown_ray() -> None:
+    """Shutdown Ray if it was started by EvoLib."""
+    global _ray_initialized
+    if ray is not None and _ray_initialized:
+        ray.shutdown()
+        _ray_initialized = False
+
+
+def map_fitness(
+    indivs: list[Indiv],
+    fitness_fn: Callable[[Indiv], float | None],
+    *,
+    backend: str = "none",
+    num_cpus: Optional[int] = None,
+    address: Optional[str] = None,
+) -> None:
+    """
+    Evaluate a list of individuals using the chosen backend.
+
+    Args:
+        indivs: List of individuals to evaluate (modified in-place).
+        fitness_fn: Fitness function that assigns indiv.fitness.
+        backend: "none" (sequential) or "ray".
+        num_cpus: Number of CPUs for Ray (optional).
+        address: Ray cluster address (optional).
+    """
+
+    if backend != "ray":
+        # Sequential fallback
+        for indiv in indivs:
+            result = fitness_fn(indiv)
+            if result is not None:
+                indiv.fitness = float(result)
+            indiv.is_evaluated = True
+        return
+
+    # Ray backend
+    _ensure_ray_initialized(num_cpus=num_cpus, address=address)
+
+    @ray.remote
+    def _eval_remote(indiv: Indiv) -> Indiv:
+        result = fitness_fn(indiv)
+        if result is not None:
+            indiv.fitness = float(result)
+        indiv.is_evaluated = True
+        return indiv
+
+    futures = [_eval_remote.remote(ind) for ind in indivs]
+    results = ray.get(futures)
+
+    # Update original objects in-place
+    for orig, res in zip(indivs, results):
+        orig.fitness = res.fitness
+        orig.extra_metrics = getattr(res, "extra_metrics", {})
+        orig.is_evaluated = True

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b2.dev5
+Version: 0.2.0b2.dev7
 Summary: A modular framework for evolutionary strategies and neuroevolution.
 Author-email: EvoLib <evolib@dismail.de>
 License: MIT License
@@ -76,6 +76,7 @@ EvoLib is a lightweight and transparent framework for evolutionary computation,
 - **Modularity**: mutation, selection, crossover, and parameter representations can be freely combined.  
 - **Educational value**: examples and a clean API make it practical for illustrating evolutionary concepts.  
 - **Neuroevolution support**: structural mutations (adding/removing neurons and connections) and evolvable networks via EvoNet.  
+- **Parallel evaluation (optional)**: basic support for [Ray](https://www.ray.io/) to speed up fitness evaluations.  
 - **Type-checked**: PEP8 compliant, and consistent code style.  
 
 
@@ -251,10 +252,9 @@ For deeper exploration, see the [full examples directory](examples/)
 - [X] Composite Parameters (multi-module individuals)
 - [X] Neuroevolution
 - [X] Topological Evolution (neurons, edges)
-- [ ] Co-Evolution & Speciation Support
+- [X] Ray Support for Parallel Evaluation (early prototypes)
 - [ ] Advanced Visualization
 - [ ] Game Environment Integration (pygame, PettingZoo - early prototypes)
-- [ ] Ray Support for Parallel Evaluation (early prototypes)
 
 
 ---

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

@@ -408,6 +408,7 @@ evolib/utils/config_loader.py
 evolib/utils/fitness.py
 evolib/utils/history_logger.py
 evolib/utils/loss_functions.py
+evolib/utils/parallel.py
 evolib/utils/plotting.py
 evolib/utils/random.py
 evolib/utils/registry.py
@@ -443,11 +444,17 @@ examples/05_advanced_topics/06_evolving_mutation_strength_as_a_module.py
 examples/06_netvector/01_netvector_sine_approximation.py
 examples/06_netvector/02_netvector_modulated_output.py
 examples/06_netvector/03_netvector_gain_and_bias.py
+examples/07_evonet/00_identity_test.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_bit_prediction.py
-examples/07_evonet/resize_all_images.py
+examples/07_evonet/05_recurrent_timeseries.py
+examples/07_evonet/06_recurrent_indicator.py
+examples/07_evonet/06_recurrent_indicator_01.py
+examples/07_evonet/06_recurrent_indicator_02.py
+examples/07_evonet/06_recurrent_trading.py
+examples/07_evonet/07_recurrent_trading_01.py
 tests/test_benchmarks.py
 tests/test_config_loader.py
 tests/test_elitism_preserves_best_fitness.py

evolib-0.2.0b2.dev7/examples/07_evonet/00_identity_test.py

@@ -0,0 +1,63 @@
+import numpy as np
+from evolib import Population, Individual, plot_approximation
+
+# Fixed test sequence
+SEQ_LEN = 100
+WARMUP_STEPS = 0
+CONFIG_FILE = "./configs/00_identity_test.yaml"
+FRAME_FOLDER = "00_frames"
+
+# Generate simple linear sequence
+full_seq = np.linspace(-1.0, 1.0, SEQ_LEN)
+input_seq = full_seq
+target_seq = full_seq
+
+# Fitness: MSE between predicted and actual (no shift)
+def eval_identity_fitness(indiv: Individual) -> float:
+    net = indiv.para["brain"].net
+    net.reset(full=True)
+
+    preds = []
+    for i in range(WARMUP_STEPS, len(input_seq)):
+        y_pred = net.calc([input_seq[i]])[0]
+        preds.append(y_pred)
+
+    y_true = target_seq[WARMUP_STEPS:]
+    preds = np.array(preds)
+    mse = np.mean((preds - y_true) ** 2)
+
+    indiv.extra_metrics["mse"] = mse
+    indiv.fitness = mse  # minimize error → maximize -mse
+    return indiv.fitness
+
+# Plot best prediction
+def plot_prediction(pop: Population) -> None:
+    best = pop.best()
+    net = best.para["brain"].net
+    net.reset(full=True)
+
+    preds = []
+    for i in range(WARMUP_STEPS, len(input_seq)):
+        y_pred = net.calc([input_seq[i]])[0]
+        preds.append(y_pred)
+
+    plot_approximation(
+        preds,
+        target_seq[WARMUP_STEPS:],
+        title=(
+            f"Identity Test: x[t] → x[t]\n"
+            f"gen={pop.generation_num}, MSE={best.extra_metrics['mse']:.6f}"
+        ),
+        pred_label="Prediction",
+        true_label="Target",
+        show=False,
+        show_grid=False,
+        save_path=f"{FRAME_FOLDER}/gen_{pop.generation_num:03d}.png",
+    )
+
+def main():
+    pop = Population(CONFIG_FILE, fitness_function=eval_identity_fitness)
+    pop.run(verbosity=1, on_generation_end=plot_prediction)
+
+if __name__ == "__main__":
+    main()