evolib 0.2.0b4.dev6__tar.gz → 0.2.0b4.dev7__tar.gz

{evolib-0.2.0b4.dev6/evolib.egg-info → evolib-0.2.0b4.dev7}/PKG-INFO

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

{evolib-0.2.0b4.dev6 → evolib-0.2.0b4.dev7}/evolib/config/evonet_component_config.py

@@ -31,25 +31,112 @@ from evolib.config.base_component_config import (
     StructuralMutationConfig,
 )
 
+Bounds = Tuple[float, float]
+
 
 class WeightsConfig(BaseModel):
-    """Configuration for connection weight initialization and bounds."""
+    # None means: no parameter-level initialization requested (preset may initialize).
+    initializer: Optional[str] = None  # normal | uniform | zero | None
+    std: Optional[float] = None
+    bounds: Bounds = (-1.0, 1.0)  # mutation/search bounds
+    init_bounds: Optional[Bounds] = None  # init-time clipping bounds
 
-    initializer: Literal["normal", "uniform", "zero"] = "normal"
-    bounds: tuple[float, float] = Field(default=(-1.0, 1.0))
-    std: Optional[float] = (
-        None  # required if initializer == "normal" (optional for now)
-    )
+    @model_validator(mode="after")
+    def _validate(self) -> "WeightsConfig":
+        # Validate bounds
+        lo, hi = self.bounds
+        if lo >= hi:
+            raise ValueError("weights.bounds must satisfy lower < upper")
+
+        if self.init_bounds is not None:
+            ilo, ihi = self.init_bounds
+            if ilo >= ihi:
+                raise ValueError("weights.init_bounds must satisfy lower < upper")
+            if not (lo <= ilo and ihi <= hi):
+                raise ValueError("weights.init_bounds must lie within weights.bounds")
+
+        # Validate initializer-specific fields
+        if self.initializer is None:
+            # Preset-based initialization
+            if self.std is not None:
+                raise ValueError(
+                    "weights.std is not allowed when " "weights.initializer is not set"
+                )
+            return self
+
+        if self.initializer == "normal":
+            if self.std is None or self.std <= 0:
+                raise ValueError(
+                    "weights.std must be set and > 0 for initializer=normal"
+                )
+
+        elif self.initializer in ("uniform", "zero"):
+            if self.std is not None:
+                raise ValueError("weights.std is only allowed for initializer=normal")
+
+        else:
+            raise ValueError(f"Unknown weights initializer: {self.initializer}")
+
+        return self
 
 
 class BiasConfig(BaseModel):
-    """Configuration for Neuron-Bias nitialization and bounds."""
+    # None means: no parameter-level initialization requested (preset may initialize).
+    initializer: Optional[str] = None  # fixed | normal | uniform | zero | None
+    std: Optional[float] = None
+    value: Optional[float] = None
+    bounds: Bounds = (-0.5, 0.5)  # mutation/search bounds
+    init_bounds: Optional[Bounds] = None  # init-time clipping bounds (optional)
 
-    initializer: Literal["fixed", "normal", "uniform", "zero"] = "normal"
-    bounds: tuple[float, float] = Field(default=(-1.0, 1.0))
-    std: Optional[float] = (
-        None  # required if initializer == "normal" (optional for now)
-    )
+    @model_validator(mode="after")
+    def _validate(self) -> "BiasConfig":
+        # Validate bounds
+        lo, hi = self.bounds
+        if lo >= hi:
+            raise ValueError("bias.bounds must satisfy lower < upper")
+
+        if self.init_bounds is not None:
+            ilo, ihi = self.init_bounds
+            if ilo >= ihi:
+                raise ValueError("bias.init_bounds must satisfy lower < upper")
+            if not (lo <= ilo and ihi <= hi):
+                raise ValueError("bias.init_bounds must lie within bias.bounds")
+
+        # Validate initializer-specific fields
+        if self.initializer is None:
+            # Preset-based initialization
+            if self.std is not None:
+                raise ValueError(
+                    "bias.std is not allowed when bias.initializer is not set"
+                )
+            if self.value is not None:
+                raise ValueError(
+                    "bias.value is not allowed when bias.initializer is not set"
+                )
+            return self
+
+        if self.initializer == "fixed":
+            if self.value is None:
+                raise ValueError("bias.value is required for initializer=fixed")
+            if self.std is not None:
+                raise ValueError("bias.std is not allowed for initializer=fixed")
+
+        elif self.initializer == "normal":
+            if self.std is None or self.std <= 0:
+                raise ValueError("bias.std must be set and > 0 for initializer=normal")
+            if self.value is not None:
+                raise ValueError("bias.value is only allowed for initializer=fixed")
+
+        elif self.initializer in ("uniform", "zero"):
+            if self.std is not None:
+                raise ValueError("bias.std is only allowed for initializer=normal")
+            if self.value is not None:
+                raise ValueError("bias.value is only allowed for initializer=fixed")
+
+        else:
+            raise ValueError(f"Unknown bias initializer: {self.initializer}")
+
+        return self
 
 
 class DelayConfig(BaseModel):
@@ -106,11 +193,12 @@ class EvoNetComponentConfig(BaseModel):
 
             weights:
               initializer: normal
+              std: 0.5
               bounds: [-1.0, 1.0]
 
             bias:
-                initializer: uniform
-                bounds: [-0.5, 0.5]
+              initializer: uniform
+              bounds: [-0.5, 0.5]
 
             mutation:
               strategy: constant

{evolib-0.2.0b4.dev6 → evolib-0.2.0b4.dev7}/evolib/initializers/evonet_initializers.py

@@ -18,6 +18,74 @@ from evolib.interfaces.enum_helpers import resolve_recurrent_kinds
 from evolib.representation.evonet import EvoNet
 
 
+def _clip(x: np.ndarray, bounds: tuple[float, float]) -> np.ndarray:
+    lo, hi = bounds
+    return np.clip(x, lo, hi)
+
+
+def _apply_weights_init(para: EvoNet, cfg: EvoNetComponentConfig) -> None:
+    weights_cfg = cfg.weights
+    size = para.net.num_weights
+
+    if weights_cfg.initializer is None:
+        return
+
+    elif weights_cfg.initializer == "zero":
+        weights = np.zeros(size, dtype=float)
+
+    elif weights_cfg.initializer == "uniform":
+        # uniform uses init_bounds if present, otherwise bounds
+        lo, hi = weights_cfg.init_bounds or weights_cfg.bounds
+        weights = np.random.uniform(lo, hi, size=size)
+
+    elif weights_cfg.initializer == "normal":
+        assert weights_cfg.std is not None
+        weights = np.random.normal(loc=0.0, scale=weights_cfg.std, size=size)
+
+        # clip ONLY if init_bounds explicitly provided
+        if weights_cfg.init_bounds is not None:
+            lo, hi = weights_cfg.init_bounds
+            weights = np.clip(weights, lo, hi)
+
+    else:
+        raise ValueError(f"Unknown weights initializer: {weights_cfg.initializer}")
+
+    para.net.set_weights(weights)
+
+
+def _apply_bias_init(para: EvoNet, cfg: EvoNetComponentConfig) -> None:
+    bias_cfg = cfg.bias
+    size = para.net.num_biases
+
+    if bias_cfg.initializer is None:
+        return
+
+    elif bias_cfg.initializer == "zero":
+        bias = np.zeros(size, dtype=float)
+
+    elif bias_cfg.initializer == "fixed":
+        assert bias_cfg.value is not None
+        bias = np.full(size, float(bias_cfg.value), dtype=float)
+
+    elif bias_cfg.initializer == "uniform":
+        lo, hi = bias_cfg.init_bounds or bias_cfg.bounds
+        bias = np.random.uniform(lo, hi, size=size)
+
+    elif bias_cfg.initializer == "normal":
+        assert bias_cfg.std is not None
+        bias = np.random.normal(loc=0.0, scale=bias_cfg.std, size=size)
+
+        # clip only if init_bounds explicitly provided
+        if bias_cfg.init_bounds is not None:
+            lo, hi = bias_cfg.init_bounds
+            bias = np.clip(bias, lo, hi)
+
+    else:
+        raise ValueError(f"Unknown bias initializer: {bias_cfg.initializer}")
+
+    para.net.set_biases(bias)
+
+
 def _apply_delay_init(para: EvoNet, cfg: EvoNetComponentConfig) -> None:
     """Initialize delay on recurrent connections only."""
 
@@ -26,19 +94,19 @@ def _apply_delay_init(para: EvoNet, cfg: EvoNetComponentConfig) -> None:
 
     delay_cfg: DelayConfig = cfg.delay
 
-    for c in para.net.get_all_connections():
-        if c.type is not ConnectionType.RECURRENT:
+    for connection in para.net.get_all_connections():
+        if connection.type is not ConnectionType.RECURRENT:
             continue
 
         if delay_cfg.initializer == "uniform" and delay_cfg.bounds is not None:
             assert delay_cfg.bounds is not None
             lo, hi = delay_cfg.bounds
-            d = int(np.random.randint(lo, hi + 1))
+            delay = int(np.random.randint(lo, hi + 1))
         else:
             assert delay_cfg.value is not None
-            d = int(delay_cfg.value)
+            delay = int(delay_cfg.value)
 
-        c.set_delay(d)
+        connection.set_delay(delay)
 
 
 def _build_architecture(
@@ -121,80 +189,57 @@ def initializer_unconnected_evonet(config: FullConfig, module: str) -> EvoNet:
     para.apply_config(cfg)
 
     _build_architecture(para, cfg, connection_init="none")
-
-    # Initialize biases
-    para.net.set_biases(np.zeros(para.net.num_biases))
+    _apply_bias_init(para, cfg)
 
     return para
 
 
 def initializer_normal_evonet(config: FullConfig, module: str) -> EvoNet:
     """
-    Initializes an EvoNet with normally distributed weights.
+    Build a standard EvoNet architecture and initialize parameters according to the
+    explicit configuration blocks.
 
-    Args:
-        config (FullConfig): Full experiment configuration
-        module (str): Module name (e.g. "brain")
+    - Topology is created via `_build_architecture(...)`.
+    - Weights are initialized using `cfg.weights`.
+    - Biases are initialized using `cfg.bias`.
+    - Delay (if configured) is initialized using `cfg.delay`.
 
-    Returns:
-        EvoNet: Initialized EvoNet representation
+    No implicit parameter initialization is performed here.
+    All parameter distributions are controlled explicitly via the config.
     """
+
     para = EvoNet()
     cfg = config.modules[module].model_copy(deep=True)
     para.apply_config(cfg)
 
-    _build_architecture(para, cfg)
+    _build_architecture(para, cfg, connection_init="zero")
     _apply_delay_init(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)
+    _apply_weights_init(para, cfg)
+    _apply_bias_init(para, cfg)
     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
+    Backward-compatible alias for the standard EvoNet initializer. Will be removed.
 
-    Returns:
-        EvoNet: Initialized EvoNet representation
+    Parameter initialization is controlled by `cfg.weights`, `cfg.bias`,
+    and `cfg.delay`.
     """
-    para = EvoNet()
-    cfg = config.modules[module].model_copy(deep=True)
-    para.apply_config(cfg)
-
-    _build_architecture(para, cfg, connection_init="random")
-    _apply_delay_init(para, cfg)
-
-    bias_bounds = cfg.bias.bounds or (-0.5, 0.5)
-    min_bias = bias_bounds[0]
-    max_bias = bias_bounds[1]
-
-    biases = np.random.uniform(min_bias, max_bias, size=para.net.num_biases)
-
-    para.net.set_biases(biases)
-    return para
+    return initializer_normal_evonet(config, module)
 
 
 def initializer_zero_evonet(config: FullConfig, module: str) -> EvoNet:
     """
-    Initializes an EvoNet with all weights and biases set to zero.
+    Build a standard EvoNet architecture and initialize all parameters to zero.
 
-    Args:
-        config (FullConfig): Full experiment configuration
-        module (str): Module name
+    - All connection weights are set to 0.
+    - All biases are set to 0.
+    - Delay initialization follows `cfg.delay` if applicable.
 
-    Returns:
-        EvoNet: Initialized EvoNet representation
+    This initializer ignores `cfg.weights` and `cfg.bias` distributions.
     """
+
     para = EvoNet()
     cfg = config.modules[module].model_copy(deep=True)
     para.apply_config(cfg)
@@ -202,27 +247,23 @@ def initializer_zero_evonet(config: FullConfig, module: str) -> EvoNet:
     _build_architecture(para, cfg, connection_init="zero")
     _apply_delay_init(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
+    Build a feedforward EvoNet and initialize parameters with an identity-like
+    structure.
 
-    This initializer encourages stable internal state retention from the start,
-    making recurrent behavior immediately available to evolution.
+    - Feedforward connections are created normally.
+    - Self-recurrent connections are added explicitly.
+    - Weights and biases are set to fixed values
+      to approximate identity behavior.
 
-    Args:
-        config (FullConfig): Full experiment configuration
-        module (str): Name of the EvoNet module in the config
-
-    Returns:
-        EvoNet: Initialized network with identity-style dynamics
+    This preset intentionally overrides standard parameter initialization.
     """
 
     SELF_LOOP_WEIGHT = 0.8

{evolib-0.2.0b4.dev6 → evolib-0.2.0b4.dev7}/evolib/representation/evonet.py

@@ -156,7 +156,11 @@ class EvoNet(ParaBase):
             raise ValueError("mutation_strength must be set.")
 
         mutation_strength = self.evo_params.mutation_strength
-        mutation_probability = self.evo_params.mutation_probability or 1.0
+        mutation_probability = (
+            self.evo_params.mutation_probability
+            if self.evo_params.mutation_probability is not None
+            else 1.0
+        )
         low, high = self.weight_bounds or (-np.inf, np.inf)
 
         for connection in self.net.get_all_connections():
@@ -166,12 +170,18 @@ class EvoNet(ParaBase):
 
         # Biases (optional override)
         if self.bias_evo_params is not None:
-            bias_strength = self.bias_evo_params.mutation_strength or mutation_strength
-            bias_probability = (
-                self.bias_evo_params.mutation_probability or mutation_probability
-            )
+            if self.bias_evo_params.mutation_strength is not None:
+                bias_strength = self.bias_evo_params.mutation_strength
+            else:
+                bias_strength = mutation_strength
+
+            if self.bias_evo_params.mutation_probability is not None:
+                bias_probability = self.bias_evo_params.mutation_probability
+            else:
+                bias_probability = mutation_probability
         else:
-            bias_strength, bias_probability = mutation_strength, mutation_probability
+            bias_strength = mutation_strength
+            bias_probability = mutation_probability
 
         low, high = self.bias_bounds or (-np.inf, np.inf)
         for neuron in self.net.get_all_neurons():
@@ -344,7 +354,11 @@ class EvoNet(ParaBase):
         # If Bias-Override exists
         if self.bias_evo_params is not None:
             bep = self.bias_evo_params
-            if ep.mutation_strategy == MutationStrategy.EXPONENTIAL_DECAY:
+
+            # Use per-scope strategy if set; otherwise fall back to global.
+            bias_strategy = bep.mutation_strategy or ep.mutation_strategy
+
+            if bias_strategy == MutationStrategy.EXPONENTIAL_DECAY:
                 bep.mutation_strength = exponential_mutation_strength(
                     bep, generation, max_generations
                 )
@@ -352,10 +366,10 @@ class EvoNet(ParaBase):
                     bep, generation, max_generations
                 )
 
-            elif ep.mutation_strategy == MutationStrategy.ADAPTIVE_GLOBAL:
+            elif bias_strategy == MutationStrategy.ADAPTIVE_GLOBAL:
                 if diversity_ema is None:
                     raise ValueError(
-                        "diversity_ema must be provided for ADAPTIVE_GLOBAL (biases)"
+                        "diversity_ema must be provided for " "ADAPTIVE_GLOBAL (biases)"
                     )
                 if bep.mutation_strength is None or bep.mutation_probability is None:
                     raise ValueError(
@@ -369,8 +383,7 @@ class EvoNet(ParaBase):
                     bep.mutation_strength, diversity_ema, bep
                 )
 
-            elif ep.mutation_strategy == MutationStrategy.ADAPTIVE_INDIVIDUAL:
-                # Ensure tau is initialized
+            elif bias_strategy == MutationStrategy.ADAPTIVE_INDIVIDUAL:
                 if bep.tau is None or bep.tau == 0.0:
                     bep.tau = adapted_tau(len(self.get_vector()))
 
@@ -379,8 +392,8 @@ class EvoNet(ParaBase):
                     or bep.max_mutation_strength is None
                 ):
                     raise ValueError(
-                        "biases override requires min/max mutation_strength for "
-                        "ADAPTIVE_INDIVIDUAL."
+                        "biases override requires min/max mutation_strength "
+                        "for ADAPTIVE_INDIVIDUAL."
                     )
                 if self.bias_bounds is None:
                     raise ValueError("bias_bounds must be set for bias adaptation.")
@@ -389,7 +402,6 @@ class EvoNet(ParaBase):
                         bep.min_mutation_strength, bep.max_mutation_strength
                     )
 
-                # Perform adaptive update
                 bounds = (bep.min_mutation_strength, bep.max_mutation_strength)
                 bep.mutation_strength = adapt_mutation_strength(bep, bounds)
 

{evolib-0.2.0b4.dev6 → evolib-0.2.0b4.dev7/evolib.egg-info}/PKG-INFO

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

{evolib-0.2.0b4.dev6 → evolib-0.2.0b4.dev7}/pyproject.toml

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

{evolib-0.2.0b4.dev6 → evolib-0.2.0b4.dev7}/tests/test_evonet_neuron_dynamics.py

@@ -17,6 +17,16 @@ def test_neuron_dynamics_config_length_matches_dim() -> None:
             dim=[1, 2, 1],
             activation=["linear", "tanh", "tanh"],
             initializer="zero_evonet",
+            weights={
+                "initializer": "normal",
+                "std": 0.5,
+                "bounds": [-1.0, 1.0],
+            },
+            bias={
+                "initializer": "normal",
+                "std": 0.1,
+                "bounds": [-0.5, 0.5],
+            },
             neuron_dynamics=[
                 {"name": "standard", "params": {}},
                 {"name": "standard", "params": {}},
@@ -44,9 +54,12 @@ def test_neuron_dynamics_applied_to_neurons() -> None:
                 "connection_density": 1.0,
                 "weights": {
                     "initializer": "normal",
+                    "std": 0.5,
                     "bounds": [-1.0, 1.0],
                 },
                 "bias": {
+                    "initializer": "normal",
+                    "std": 0.1,
                     "bounds": [-0.5, 0.5],
                 },
                 "neuron_dynamics": [

{evolib-0.2.0b4.dev6 → evolib-0.2.0b4.dev7}/tests/test_initializer_evonet.py

@@ -16,6 +16,16 @@ def test_normal_initializer_evonet_builds_expected_structure() -> None:
                 "dim": [2, 3, 1],
                 "activation": "linear",
                 "initializer": "normal_evonet",
+                "weights": {
+                    "initializer": "normal",
+                    "std": 0.5,
+                    "bounds": [-1.0, 1.0],
+                },
+                "bias": {
+                    "initializer": "normal",
+                    "std": 0.1,
+                    "bounds": [-0.5, 0.5],
+                },
                 "mutation": {
                     "strategy": "constant",
                     "strength": 0.1,