evolib 0.2.0b4.dev5__tar.gz → 0.2.0b4.dev7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b4.dev5
+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.dev5 → evolib-0.2.0b4.dev7}/docs/config_guide.md

@@ -148,14 +148,15 @@ modules:
     initializer: normal_evonet
     weights:
       bounds: [-5.0, 5.0]
-    bias_bounds:   [-1.0, 1.0]
+    bias:
+        bounds: [-1.0, 1.0]
 
     recurrent: direct   # REQUIRED for delay to have any effect
 
     # NOTE: Delays only apply to recurrent connections.
     # If `recurrent` is not enabled, this block has no effect.
     delay:
-      initializer: random   # random | fixed
+      initializer: uniform   # uniform | fixed
       bounds: [1, 8]        # only for random
       # value: 3            # only for fixed
 

{evolib-0.2.0b4.dev5 → evolib-0.2.0b4.dev7}/docs/config_parameter.md

@@ -188,7 +188,7 @@ modules:
 | `activation`      | str \| list[str]    | —       | If list: activation per layer. If str: used for non-input layers; input layer is treated as linear. |
 | `initializer`     | str                 | —       | Network initialization method (e.g. `normal_evonet`, `unconnected_evonet`). |
 | `weights`         | dict                | —       | Weight init and bounds configuration (initializer, bounds, optional params). | 
-| `bias_bounds`     | list[float] \| null | null    | `[min_b, max_b]` hard clipping bounds for neuron biases. |
+| `bias`            | dict                | —       | Bias init and bounds configuration (initializer, bounds, optional params). | 
 | `neuron_dynamics` | list[dict] \| null  | null    | Optional per-layer neuron dynamics specification. Must match `len(dim)`. |
 | `mutation`        | dict \| null        | null    | Mutation settings for weights, biases, activations, delay, and structure. |
 | `crossover`       | dict \| null        | null    | Optional crossover settings (weight/bias level). |
@@ -200,6 +200,13 @@ modules:
 |bounds	     | list[float]	| [-1.0, 1.0]	| Hard clipping bounds [min_w, max_w]. |
 |std         | float | null	|null | Std-dev for normal (if used). |
 
+##### bias block
+|Parameter	 | Type	 | Default	 | Explanation |
+|------------|-------|-----------|-------------|
+|initializer | str   | "normal"	 | Weight initializer preset (normal, uniform, zero, …). |
+|bounds	     | list[float]	| [-1.0, 1.0]	| Hard clipping bounds [min_w, max_w]. |
+|std         | float | null	|null | Std-dev for normal (if used). |
+
 ---
 
 #### EvoNet Initializer
@@ -210,7 +217,7 @@ The EvoNet module uses:
 |---------------------|------------------------------------|----------------------------------|---------------------------------------------|
 | `normal_evonet`     | Normal(0, 0.5)                     | Normal(0, 0.5)                   | Default initializer for general use         |
 | `unconnected_evonet`| None                               | 0                                | For pure structural growth; empty topology  |
-| `random_evonet`     | Random                             | Uniform(bias_bounds)             | For broader stochastic exploration           |
+| `random_evonet`     | Random                             | Uniform(bias bounds)             | For broader stochastic exploration           |
 | `zero_evonet`       | 0                                  | 0                                | Deterministic baseline; debugging            |
 | `identity_evonet`   | Small random                       | Small random                     | Designed for stable recurrent memory         |
 
@@ -268,7 +275,7 @@ modules:
     type: evonet
     ...
     delay:
-      initializer: random   # random | fixed
+      initializer: uniform  # uniform | fixed
       bounds: [1, 8]        # only for random
       # value: 3            # only for fixed
 ```
@@ -433,7 +440,7 @@ modules:
     initializer: normal_evonet
 
     delay:
-      initializer: random
+      initializer: uniform
       bounds: [1, 8]
 
     mutation:

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

@@ -31,45 +31,142 @@ 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):
+    # 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)
+
+    @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):
     """Delay initialization for recurrent connections."""
 
-    initializer: Literal["static", "random"] = Field(
-        default="static",
+    initializer: Literal["fixed", "uniform"] = Field(
+        default="fixed",
         description="Delay initializer for recurrent connections.",
     )
 
     value: Optional[int] = Field(
         default=None,
         ge=1,
-        description="Fixed delay value (required for initializer=static).",
+        description="Fixed delay value (required for initializer=fixed).",
     )
 
     bounds: Optional[Tuple[int, int]] = Field(
         default=None,
         description="Inclusive [min, max] delay bounds (required for "
-        "initializer=random).",
+        "initializer=uniform).",
     )
 
     @model_validator(mode="after")
     def _validate(self) -> "DelayConfig":
-        if self.initializer == "static":
+        if self.initializer == "fixed":
             if self.value is None:
-                raise ValueError("delay.value is required for initializer=static")
-        elif self.initializer == "random":
+                raise ValueError("delay.value is required for initializer=fixed")
+        elif self.initializer == "uniform":
             if self.bounds is None:
-                raise ValueError("delay.bounds is required for initializer=random")
+                raise ValueError("delay.bounds is required for initializer=uniform")
             lo, hi = self.bounds
             if lo < 1 or hi < 1:
                 raise ValueError("delay bounds must be >= 1 (recurrent-only)")
@@ -96,9 +193,13 @@ class EvoNetComponentConfig(BaseModel):
 
             weights:
               initializer: normal
+              std: 0.5
               bounds: [-1.0, 1.0]
 
-            bias_bounds: [-0.5, 0.5]
+            bias:
+              initializer: uniform
+              bounds: [-0.5, 0.5]
+
             mutation:
               strategy: constant
               probability: 0.8
@@ -151,7 +252,7 @@ class EvoNetComponentConfig(BaseModel):
 
     # Numeric bounds for values; used by initialization and mutation
     weights: WeightsConfig = Field(default_factory=WeightsConfig)
-    bias_bounds: Tuple[float, float] = (-0.5, 0.5)
+    bias: BiasConfig = Field(default_factory=BiasConfig)
 
     # Optional delay initialization for recurrent connections
     delay: Optional[DelayConfig] = None
@@ -192,15 +293,6 @@ class EvoNetComponentConfig(BaseModel):
             raise ValueError("All layer sizes in dim must be non-negative integers")
         return dim
 
-    @field_validator("bias_bounds")
-    @classmethod
-    def check_bias_bounds(cls, bounds: Tuple[float, float]) -> Tuple[float, float]:
-        """Validate that bias_bounds are well-formed (min < max)."""
-        low, high = bounds
-        if low >= high:
-            raise ValueError("bias_bounds must satisfy min < max")
-        return bounds
-
     @field_validator("activation")
     @classmethod
     def validate_activation_length(

{evolib-0.2.0b4.dev5 → 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 == "random" and delay_cfg.bounds is not None:
+        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.dev5 → evolib-0.2.0b4.dev7}/evolib/representation/evonet.py

@@ -111,7 +111,7 @@ class EvoNet(ParaBase):
 
         # Bounds
         self.weight_bounds = cfg.weights.bounds or (-1.0, 1.0)
-        self.bias_bounds = cfg.bias_bounds or (-0.5, 0.5)
+        self.bias_bounds = cfg.bias.bounds or (-0.5, 0.5)
 
         self.connection_scope = cfg.connection_scope
         self.connection_density = cfg.connection_density
@@ -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.dev5 → evolib-0.2.0b4.dev7/evolib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolib
-Version: 0.2.0b4.dev5
+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.dev5 → evolib-0.2.0b4.dev7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evolib"
-version = "0.2.0b4.dev5"
+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.dev5 → 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,14 @@ def test_neuron_dynamics_applied_to_neurons() -> None:
                 "connection_density": 1.0,
                 "weights": {
                     "initializer": "normal",
+                    "std": 0.5,
                     "bounds": [-1.0, 1.0],
                 },
-                "bias_bounds": [-0.5, 0.5],
+                "bias": {
+                    "initializer": "normal",
+                    "std": 0.1,
+                    "bounds": [-0.5, 0.5],
+                },
                 "neuron_dynamics": [
                     {"name": "standard", "params": {}},
                     {"name": "leaky", "params": {"alpha": 0.25}},