evolib 0.2.0b2.dev2__tar.gz → 0.2.0b2.dev3__tar.gz

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

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

{evolib-0.2.0b2.dev2 → evolib-0.2.0b2.dev3}/evolib/api.py

@@ -42,6 +42,7 @@ from evolib.utils.loss_functions import (
 )
 from evolib.utils.plotting import (
     plot_approximation,
+    plot_bit_prediction,
     plot_diversity,
     plot_fitness,
     plot_fitness_comparison,
@@ -60,6 +61,7 @@ __all__ = [
     "plot_fitness",
     "plot_approximation",
     "save_combined_net_plot",
+    "plot_bit_prediction",
     "plot_history",
     "plot_diversity",
     "plot_mutation_trends",

{evolib-0.2.0b2.dev2 → evolib-0.2.0b2.dev3}/evolib/config/evonet_component_config.py

@@ -13,7 +13,8 @@ config resolution.
 
 from typing import Literal, Optional, Tuple, Union
 
-from pydantic import BaseModel, Field, field_validator
+from evonet.activation import ACTIVATIONS
+from pydantic import BaseModel, Field, field_validator, validator
 from pydantic_core import core_schema
 
 from evolib.config.base_component_config import (
@@ -55,6 +56,16 @@ class EvoNetComponentConfig(BaseModel):
     # Either a single activation function or one per layer
     activation: Union[str, list[str]] = "tanh"
 
+    # Whitelist for random activation selection
+    activations_allowed: Optional[list[str]] = Field(
+        default=None,
+        description="Whitelist of activation names applied to "
+        "neurons in hidden layers.",
+    )
+
+    # Recurrent connections
+    recurrent: Optional[Literal["none", "direct", "local", "all"]] = "none"
+
     # Name of the initializer function (resolved via initializer registry)
     initializer: str = Field(..., description="Name of the initializer to use")
 
@@ -101,3 +112,26 @@ class EvoNetComponentConfig(BaseModel):
         if isinstance(act, list) and dim and len(act) != len(dim):
             raise ValueError("Length of 'activation' list must match 'dim'")
         return act
+
+    @validator("activations_allowed", each_item=True)
+    def validate_activation_name(cls, act_name: str) -> str:
+        """Ensure only valid activation function names are allowed."""
+        if act_name not in ACTIVATIONS:
+            raise ValueError(
+                f"Invalid activation function '{act_name}'. "
+                f"Valid options are: {list(ACTIVATIONS.keys())}"
+            )
+        return act_name
+
+    @validator("recurrent")
+    def validate_recurrent(cls, recurrent: Optional[str]) -> str:
+        """Ensure recurrent preset is valid and normalized."""
+        if recurrent is None:
+            return "none"
+        allowed = {"none", "direct", "local", "all"}
+        if recurrent not in allowed:
+            raise ValueError(
+                f"Invalid recurrent preset '{recurrent}'. "
+                f"Valid options are: {sorted(allowed)}"
+            )
+        return recurrent

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

@@ -657,6 +657,10 @@ class Pop:
         if sort:
             self.sort_by_fitness()
 
+    def step(self) -> None:
+        """Alias for run_one_generation()."""
+        return self.run_one_generation()
+
     def run(
         self,
         *,

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

@@ -19,7 +19,10 @@ from evolib.config.base_component_config import StructuralMutationConfig
 from evolib.config.evonet_component_config import EvoNetComponentConfig
 from evolib.interfaces.enums import MutationStrategy
 from evolib.interfaces.types import ModuleConfig
-from evolib.operators.evonet_structural_mutation import mutate_structure
+from evolib.operators.evonet_structural_mutation import (
+    mutate_structure,
+    resolve_recurrent_kinds,
+)
 from evolib.operators.mutation import (
     adapt_mutation_probability_by_diversity,
     adapt_mutation_strength,
@@ -111,6 +114,7 @@ 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:
@@ -119,11 +123,16 @@ class EvoNet(ParaBase):
             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":
-                activation_name = random_function_name()
+                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()
 
@@ -137,10 +146,13 @@ class EvoNet(ParaBase):
                 # Hidden Layer
                 role = NeuronRole.HIDDEN
 
-            if num_neurons > 0:
-                self.net.add_neuron(
-                    count=num_neurons, activation=activation_name, role=role
-                )
+            recurrent_kinds = resolve_recurrent_kinds(cfg.recurrent)
+            self.net.add_neuron(
+                count=num_neurons,
+                activation=activation_name,
+                role=role,
+                recurrent=recurrent_kinds if role != NeuronRole.INPUT else None,
+            )
 
     def calc(self, input_values: list[float]) -> list[float]:
         return self.net.calc(input_values)

{evolib-0.2.0b2.dev2 → evolib-0.2.0b2.dev3}/evolib/utils/plotting.py

@@ -553,6 +553,95 @@ def save_combined_net_plot(
         combined.save(path)
 
 
+def plot_bit_prediction(
+    pred_values: list[int],
+    true_bits: list[int],
+    save_path: str,
+    input_bits: list[int] | None = None,
+    title: str = "Bit Prediction",
+    show: bool = False,
+    dpi: int = 150,
+) -> None:
+    """
+    Visualize bit sequence prediction over time.
+
+    This plot combines two views:
+      - A raster plot (top) showing discrete input/target/predicted bits
+      - A line/scatter plot (bottom) showing target vs. predicted values
+
+    Parameters
+    ----------
+    true_bits : list[int]
+        Ground truth sequence of bits (0/1).
+    pred_values : list[float]
+        Predicted values (will be shown as continuous in line plot,
+        and rounded to 0/1 in raster plot).
+    input_bits : list[int], optional
+        Optional input sequence of bits (0/1). If given, it is shown
+        in the raster plot above target and prediction.
+    save_path : str
+        File path to save the plot image.
+    title : str, optional
+        Title of the figure. Default is "Bit Prediction".
+    show : bool, optional
+        If True, show the plot window interactively. Default: False.
+    dpi : int, optional
+        Resolution for saving the figure.
+
+    Notes
+    -----
+    - This function is specialized for visualization of
+      bit prediction tasks. For general regression or function
+      approximation, use `plot_approximation`.
+    """
+    pred_round = np.rint(pred_values).astype(int)
+
+    # build raster data
+    rows = []
+    row_labels = []
+    if input_bits is not None:
+        rows.append(np.asarray(input_bits, dtype=int))
+        row_labels.append("Input")
+    # if true_bits is not None:
+    #    rows.append(np.asarray(true_bits, dtype=int))
+    #    row_labels.append("Target")
+    rows.append(pred_round)
+    row_labels.append("Pred")
+
+    # encode to 4-class grid: (row, value)
+    grid = np.vstack(rows)
+
+    # plotting
+    fig, axes = plt.subplots(2, 1, figsize=(10, 6), constrained_layout=True)
+
+    # raster view
+    axes[0].imshow(grid, aspect="auto", interpolation="nearest", cmap="Greys")
+    axes[0].set_yticks(range(len(row_labels)))
+    axes[0].set_yticklabels(row_labels)
+    axes[0].set_xticks([])
+    axes[0].set_title(title)
+
+    # line/scatter view
+    x = np.arange(len(true_bits))
+    axes[1].plot(x, true_bits, "ko", label="Target", markersize=4)
+    axes[1].plot(x, pred_values, "r-", label="Prediction", alpha=0.7)
+    axes[1].set_xlim(0, len(true_bits))
+
+    axes[1].set_ylim(-0.2, 1.2)
+    axes[1].set_xlabel("Time step")
+    axes[1].set_ylabel("Value")
+    axes[1].legend(loc="upper right")
+
+    # save/show
+    if save_path:
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        plt.savefig(save_path, dpi=dpi)
+
+    if show:
+        plt.show()
+    plt.close()
+
+
 def save_current_plot(filename: str, dpi: int = 300) -> None:
     """Save the current matplotlib figure to file."""
     plt.savefig(filename, dpi=dpi)

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

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

evolib-0.2.0b2.dev3/examples/07_evonet/04_recurrent_bitseq.py

@@ -0,0 +1,103 @@
+"""
+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.
+"""
+
+from evolib import Population, Individual, plot_bit_prediction
+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
+
+def lfsr_sequence(length: int, seed: int = 0b10011, taps=(5, 2)) -> list[int]:
+    """
+    Generate a binary sequence using an n-bit LFSR.
+
+    Parameters
+    ----------
+    length : int
+        Number of output bits to generate.
+    seed : int, optional
+        Initial state (must be non-zero). Default: 0b10011.
+    taps : tuple[int], optional
+        Tap positions (1-based, e.g. (5, 2) for x^5 + x^2 + 1).
+
+    Returns
+    -------
+    list[int]
+        Generated bit sequence.
+    """
+    n = max(taps)
+    if seed == 0:
+        raise ValueError("Seed must be non-zero for LFSR.")
+    state = seed & ((1 << n) - 1)
+
+    seq = []
+    for _ in range(length):
+        bit = state & 1
+        seq.append(bit)
+        # compute feedback from taps
+        fb = 0
+        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.
+    """
+    net: EvoNet = indiv.para["brain"].net
+    net.reset(full=True)
+
+    total_error = 0.0
+    for t in range(len(input_seq)):
+        output = net.calc([input_seq[t]])[0]
+        if t >= warmup_steps:
+            error = output - target_seq[t]
+            total_error += error**2
+
+    return total_error / (len(input_seq) - warmup_steps)
+
+
+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]
+
+    plot_bit_prediction(
+        true_bits=target_seq,
+        pred_values=y_preds,
+        input_bits=input_seq,
+        title=f"Bit Prediction (gen={pop.generation_num}, MSE={best.fitness:.4f})",
+        save_path=f"{FRAME_FOLDER}/gen_{pop.generation_num:03d}.png",
+    )
+    
+    best.para["brain"].net.print_graph("test.png",fillcolors_on=True)
+
+
+if __name__ == "__main__":
+    pop = Population(CONFIG_FILE, fitness_function=fitness_bitseq)
+    pop.run(verbosity=1, on_generation_end=save_plot)
+
+    best = pop.best()
+    best.para["brain"].net.print_graph("test.png",fillcolors_on=True)
+

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

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

evolib-0.2.0b2.dev2/examples/07_evonet/04_recurrent_bitseq.py

@@ -1,63 +0,0 @@
-from evolib import Population, Individual, FitnessFunction, plot_approximation
-from evolib.representation.evonet import EvoNet
-import matplotlib.pyplot as plt
-import numpy as np
-
-FRAME_FOLDER = "04_frames_point"
-
-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
-warmup_steps = 11
-
-
-def fitness_bitseq(indiv: Individual) -> float:
-    """
-    Evaluate how well the EvoNet predicts the next bit in a fixed sequence.
-    """
-    net: EvoNet = indiv.para["brain"].net
-    net.reset(full=True)
-
-    total_error = 0.0
-    for t in range(len(input_seq)):
-        output = net.calc([input_seq[t]])[0]
-        if t >= warmup_steps:
-            error = output - target_seq[t]
-            total_error += error**2
-    
-    return total_error / (len(input_seq) - warmup_steps)
-
-
-def save_plot(pop: Population):
-    """
-    Plot network predictions vs target values over time.
-    """
-    best = pop.best()
-    y_preds = [best.para["brain"].net.calc([bit])[0] for bit in input_seq]
-
-    plot_approximation(
-        y_preds,
-        target_seq,
-        title=f"Bit Prediction over Time (gen={pop.generation_num}, "
-        f"MSE={best.fitness:.4f})",
-        pred_label="Prediction",
-        show=False,
-        show_grid=False,
-        save_path=f"{FRAME_FOLDER}/gen_{pop.generation_num:03d}.png",
-        y_limits=(-0.2, 1.2),
-        true_marker="o",
-        pred_marker="o",
-        true_lw=0,
-        pred_lw=1,
-        true_ls="",
-        pred_ls="",
-    )
-
-    print(pop.mu)
-
-
-if __name__ == "__main__":
-    pop = Population("configs/04_recurrent_bitseq.yaml", 
-                     fitness_function = fitness_bitseq)
-    pop.run(verbosity=1, on_generation_end=save_plot)
-#    pop.run(verbosity=2)
-