evolib 0.2.0b4.dev8__tar.gz → 0.2.0b4.dev10__tar.gz

{evolib-0.2.0b4.dev8/evolib.egg-info → evolib-0.2.0b4.dev10}/PKG-INFO

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

{evolib-0.2.0b4.dev8 → evolib-0.2.0b4.dev10}/docs/config_guide.md

@@ -30,7 +30,7 @@ evolution:
 modules:
   test-vector:              # logical module name
     type: vector
-    initializer: random_vector
+    initializer: uniform
     dim: 2
     bounds: [-1.0, 1.0]
 
@@ -89,7 +89,7 @@ modules:
   xs:
     type: vector
     dim: 6
-    initializer: random_vector
+    initializer: uniform
     bounds: [0.0, 6.283185307]   # [0, 2π]
     mutation:
       strategy: adaptive_individual
@@ -120,6 +120,11 @@ This configuration demonstrates EvoNet evolution: weight mutation, bias-specific
 
 `dim: [2, 0, 0, 1]` starts with empty hidden layers, letting structural mutation grow nodes and edges.
 
+Connectivity:
+- `scope` controls which feedforward edges are allowed at initialization.
+- `density` controls how many of those allowed edges are actually created at init.
+- `recurrent` enables recurrent edge kinds (empty list means none).
+
 Topology constraints:
 - `max_neurons` and `max_connections` keep growth bounded (these are the current names; avoid older `max_nodes/max_edges`).
 
@@ -127,6 +132,8 @@ Delay:
 - `delay:` initializes delays of recurrent connections at build time.
 - `mutation.delay:` mutates delays during evolution (recurrent connections only).
 
+
+
 ```yaml
 parent_pool_size: 20
 offspring_pool_size: 40
@@ -145,17 +152,22 @@ modules:
     type: evonet
     dim: [2, 0, 0, 1]       # hidden layers start empty
     activation: [linear, tanh, tanh, sigmoid]
+
+    connectivity:
+      scope: crosslayer          # adjacent | crosslayer
+      density: 1.0               # (0, 1]
+      recurrent: [direct]        # [], [direct], [lateral], [indirect]
+    
     weights:
       initializer: normal
       std: 0.5
       bounds: [-5.0, 5.0]
+    
     bias:      
       initializer: normal
       std: 0.5
       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:

{evolib-0.2.0b4.dev8 → evolib-0.2.0b4.dev10}/docs/config_parameter.md

@@ -152,7 +152,7 @@ The `vector` module defines an evolvable parameter vector.
 | `type`                           | `"vector"`                                        | —              | Module type identifier. |
 | `dim`                            | `int \| list[int]`                                | —              | Vector length (`int`) or structured dimensions (`list[int]`). Must be > 0. |
 | `structure`                      | `"flat" \| "net"                                  | `"flat"`       | Structural interpretation of the vector. |
-| `initializer`                    | `str`                                             | —              | Initializer name from the registry (e.g. `random_vector`, `zero_vector`, `normal_vector`, `fixed_vector`). |
+| `initializer`                    | `str`                                             | —              | Initializer name from the registry (e.g. `uniform`, `zero`, `normal`, `fixed`). |
 | `bounds`                         | `tuple[float, float]`                             | `[-1.0, 1.0]`  | Hard clamp range applied after mutation. |
 | `init_bounds`                    | `tuple[float, float] \| null`                     | `null`         | Clamp applied only during initialization. Falls back to `bounds` if not set. |
 | `shape`                          | `tuple[int, ...] \| null`                         | `null`         | Optional explicit shape. If set, `dim = product(shape)`. Shape is retained as metadata. |
@@ -232,7 +232,7 @@ modules:
   main:
     type: vector
     dim: 8
-    initializer: random_vector
+    initializer: uniform
     bounds: [-1.0, 1.0]
 
     mutation:
@@ -288,13 +288,31 @@ modules:
 |-------------------|---------------------|---------|-------------|
 | `dim`             | list[int]           | —       | Layer sizes, e.g. `[4, 0, 0, 2]`. Hidden layers can start empty (0) and grow through structural mutation. |
 | `activation`      | str \| list[str]    | —       | If list: activation per layer. If str: used for non-input layers; input layer is treated as linear. |
-| `initializer`     | str                 | default_evonet       | Topology preset (e.g. `default_evonet`, `unconnected_evonet`, `identity_evonet`). Parameter initialization is configured via `weights`, `bias`, and `delay`. |
+| `initializer`     | str                 | default | Topology preset (e.g. `default`, `unconnected`, `identity`). Parameter initialization is configured via `weights`, `bias`, and `delay`. |
+| `connectivity`    | `dict`                   | —       | **Required.** Defines feedforward scope/density and allowed recurrent kinds. |
 | `weights`         | dict                | —       | Weight init and bounds configuration (initializer, bounds, optional params). | 
 | `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). |
 
+#### Connectivity (`connectivity`)
+
+| Field       | Type                         | Default | Notes |
+|------------|------------------------------|---------|------|
+| `scope`    | `"adjacent" \| "crosslayer"` | —       | **Required.** Allowed feedforward edge scope at initialization. |
+| `density`  | `float`                      | —       | **Required.** Fraction of allowed feedforward edges created at init `(0,1]`. |
+| `recurrent`| `list[str]`                  | `[]`    | Allowed recurrent edge kinds. Empty list means none. |
+
+Example:
+
+```yaml
+connectivity:
+  scope: crosslayer
+  density: 0.5
+  recurrent: [direct]
+```
+
 ##### weights block
 |Parameter	 | Type	 | Default	 | Explanation |
 |------------|-------|-----------|-------------|
@@ -324,9 +342,9 @@ Allowed presets:
 
 | Initializer            | Meaning (topology only) |
 |------------------------|-------------------------|
-| `default_evonet`       | Standard EvoNet topology preset (uses `connection_scope`, `connection_density`, and `recurrent`). |
-| `unconnected_evonet`   | Creates neurons/layers but starts with **no connections** (use structural mutation to grow). |
-| `identity_evonet`      | Special preset intended for stable recurrent memory (may override parameters internally; see notes below). |
+| `default`       | Standard EvoNet topology preset (uses `connection_scope`, `connection_density`, and `recurrent`). |
+| `unconnected`   | Creates neurons/layers but starts with **no connections** (use structural mutation to grow). |
+| `identity`      | Special preset intended for stable recurrent memory (may override parameters internally; see notes below). |
 
 ---
 
@@ -493,13 +511,12 @@ structural:
 
 ### Topology constraints
 
-| Field                | Type          | Default  | Description |
-|---------------------|---------------|----------|-------------|
-| `recurrent`          | str           | `none`   | Controls recurrence: `none`, `direct`, `local` or `all`. |
-| `connection_scope`   | str           | `adjacent` | Allowed layer connectivity: `adjacent` (neighbor layers only) or `crosslayer` (any-to-any). |
-| `connection_density` | float         | 1.0     | Fraction of possible connections initialized at creation time. |
-| `max_neurons`        | int \| null   | null     | Maximum number of non-input neurons (`null` = unlimited). |
-| `max_connections`    | int \| null   | null     | Maximum number of edges (`null` = unlimited). |
+| Field              | Type                           | Default     | Description |
+|-------------------|--------------------------------|-------------|-------------|
+| `recurrent`        | `list[str]`                    | `[]`        | Allowed recurrent kinds for `add_connection`. Empty list means none. |
+| `connection_scope` | `"adjacent" \| "crosslayer" \| null` | `"adjacent"` | Constraint for structural add-neuron / add-connection edge placement. |
+| `max_neurons`      | `int \| null`                  | `null`      | Upper bound on total neurons allowed (implementation-defined counting). |
+| `max_connections`  | `int \| null`                  | `null`      | Upper bound on total connections allowed. |
 
 ---
 
@@ -544,7 +561,6 @@ modules:
     type: evonet
     dim: [4, 0, 0, 2]
     activation: [linear, tanh, tanh, tanh]
-    initializer: normal_evonet
 
     delay:
       initializer: uniform

{evolib-0.2.0b4.dev8 → evolib-0.2.0b4.dev10}/evolib/config/base_component_config.py

@@ -8,10 +8,11 @@ should be configured, not *how* it is executed. Any runtime behavior belongs
 into the respective Para* representations and operator modules.
 """
 
-from typing import Literal, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from evonet.activation import ACTIVATIONS
-from pydantic import BaseModel, ConfigDict, Field, model_validator, validator
+from evonet.enums import RecurrentKind
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from evolib.interfaces.enums import (
     CrossoverOperator,
@@ -221,15 +222,21 @@ class AddNeuron(BaseModel):
         "neurons in hidden layers.",
     )
 
-    @validator("activations_allowed", each_item=True)
-    def validate_activation_name(cls, act_name: str) -> str:
+    @field_validator("activations_allowed")
+    @classmethod
+    def validate_activations_allowed(
+        cls, acts: Optional[list[str]]
+    ) -> Optional[list[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
+        if acts is None:
+            return None
+        for a in acts:
+            if a not in ACTIVATIONS:
+                raise ValueError(
+                    f"Invalid activation function '{a}'. "
+                    f"Valid options are: {sorted(ACTIVATIONS.keys())}"
+                )
+        return acts
 
 
 class RemoveNeuron(BaseModel):
@@ -267,7 +274,12 @@ class StructuralTopology(BaseModel):
     mutation operators.
     """
 
-    recurrent: Optional[Literal["none", "direct", "local", "all"]] = "none"
+    recurrent: list[RecurrentKind] = Field(
+        default_factory=list,
+        description="Allowed recurrent edge kinds for structural "
+        "add_connection. Empty means none.",
+    )
+
     connection_scope: Optional[Literal["adjacent", "crosslayer"]] = "adjacent"
 
     max_neurons: Optional[int] = Field(
@@ -282,21 +294,34 @@ class StructuralTopology(BaseModel):
         ge=1,
     )
 
+    @field_validator("recurrent", mode="before")
+    @classmethod
+    def normalize_recurrent(cls, v: Any) -> list[RecurrentKind]:
+        """
+        Allow YAML convenience values like:
+            recurrent: none
+            recurrent: []
+        """
+        if v is None:
+            return []
+        if isinstance(v, str):
+            if v.lower() == "none":
+                return []
+            return [v]
+        return v
+
     @model_validator(mode="after")
     def _validate_topology(self) -> "StructuralTopology":
-        if self.recurrent not in {None, "none", "direct", "local", "all"}:
-            raise ValueError(f"Invalid recurrent value: {self.recurrent}")
-
         if self.connection_scope not in {None, "adjacent", "crosslayer"}:
             raise ValueError(f"Invalid connection_scope: {self.connection_scope}")
 
-        # Only positive limits allowed
         if self.max_connections is not None and self.max_connections <= 0:
             raise ValueError("max_connections must be > 0")
-
         if self.max_neurons is not None and self.max_neurons <= 0:
             raise ValueError("max_neurons must be > 0")
 
+        # ensure deterministic unique list
+        self.recurrent = sorted(set(self.recurrent), key=lambda x: x.value)
         return self
 
 

{evolib-0.2.0b4.dev8 → evolib-0.2.0b4.dev10}/evolib/config/evonet_component_config.py

@@ -11,16 +11,16 @@ After parsing, raw dicts are converted into this strongly typed Pydantic model d
 config resolution.
 """
 
-from typing import Literal, Optional, Tuple, Union
+from typing import Any, Literal, Optional, Tuple, Union
 
 from evonet.activation import ACTIVATIONS
+from evonet.enums import RecurrentKind
 from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
     field_validator,
     model_validator,
-    validator,
 )
 from pydantic_core import core_schema
 
@@ -30,10 +30,60 @@ from evolib.config.base_component_config import (
     EvoNetNeuronDynamicsConfig,
     StructuralMutationConfig,
 )
+from evolib.interfaces.enums import RepresentationType
 
 Bounds = Tuple[float, float]
 
 
+class ConnectivityConfig(BaseModel):
+    """
+    EvoNet connectivity configuration.
+
+    recurrent:
+        Allowed recurrent edge kinds (DIRECT/LATERAL/INDIRECT).
+        If omitted, no recurrent edges are allowed.
+
+    scope:
+        adjacent  -> only adjacent-layer feedforward connections during init
+        crosslayer -> cross-layer feedforward connections during init
+
+    density:
+        Fraction of allowed feedforward edges to create at init (0 < density <= 1).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    recurrent: list[RecurrentKind] = Field(default_factory=list)
+
+    # Required: must be explicitly set in YAML
+    scope: Literal["adjacent", "crosslayer"]
+
+    # Required: must be explicitly set in YAML
+    density: float = Field(..., gt=0.0, le=1.0)
+
+    @field_validator("recurrent", mode="before")
+    @classmethod
+    def normalize_recurrent(cls, v: Any) -> list[RecurrentKind]:
+        """
+        Allow YAML convenience values like:
+            recurrent: none
+            recurrent: []
+        """
+        if v is None:
+            return []
+        if isinstance(v, str):
+            if v.lower() == "none":
+                return []
+            return [v]
+        return v
+
+    @model_validator(mode="after")
+    def _normalize(self) -> "ConnectivityConfig":
+        # deterministic, unique
+        self.recurrent = sorted(set(self.recurrent), key=lambda x: x.value)
+        return self
+
+
 class WeightsConfig(BaseModel):
     # None means: no parameter-level initialization requested (preset may initialize).
     initializer: Optional[str] = None  # normal | uniform | zero | None
@@ -208,7 +258,10 @@ class EvoNetComponentConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     # Module type is fixed to "evonet"
-    type: Literal["evonet"] = "evonet"
+    type: RepresentationType = Field(
+        default=RepresentationType.EVONET,
+        description='Fixed module discriminator; must be "evonet" for this schema.',
+    )
 
     # Layer structure: list of neuron counts per layer [input, hidden..., output]
     dim: list[int]
@@ -223,33 +276,13 @@ class EvoNetComponentConfig(BaseModel):
         "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(
-        default="default_evonet", description="Name of the initializer to use"
+        default="default", description="Name of the initializer to use"
     )
 
-    # Connection topology for initialization
-    connection_scope: Literal["adjacent", "crosslayer"] = Field(
-        default="adjacent",
-        description=(
-            "Defines how layers are connected during initialization. "
-            "'adjacent' connects only consecutive layers, while 'crosslayer' "
-            "connects all earlier layers to all later layers."
-        ),
-    )
-
-    connection_density: float = Field(
-        default=1.0,
-        ge=0.0,
-        le=1.0,
-        description=(
-            "Fraction of possible connections actually created during initialization. "
-            "1.0 = fully connected, <1.0 = sparse."
-        ),
-    )
+    # Connectivity
+    connectivity: ConnectivityConfig
 
     # Numeric bounds for values; used by initialization and mutation
     weights: WeightsConfig = Field(default_factory=WeightsConfig)
@@ -276,9 +309,9 @@ class EvoNetComponentConfig(BaseModel):
         Parameter initialization is handled exclusively via weights/bias/delay blocks.
         """
         allowed = {
-            "default_evonet",
-            "unconnected_evonet",
-            "identity_evonet",
+            "default",
+            "unconnected",
+            "identity",
         }
 
         if name not in allowed:
@@ -331,45 +364,19 @@ class EvoNetComponentConfig(BaseModel):
             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
-
-    @field_validator("connection_scope")
+    @field_validator("activations_allowed")
     @classmethod
-    def validate_connection_scope(cls, scope: str) -> str:
-        """Ensure connection_scope is one of the supported options."""
-        allowed = {"adjacent", "crosslayer"}
-        if scope not in allowed:
-            raise ValueError(
-                f"Invalid connection_scope '{scope}'. "
-                f"Valid options are: {sorted(allowed)}"
-            )
-        return scope
+    def validate_activations_allowed(
+        cls, acts: Optional[list[str]]
+    ) -> Optional[list[str]]:
+        """Validate that all activation names are known."""
+        if acts is None:
+            return None
 
-    @field_validator("connection_density")
-    @classmethod
-    def validate_connection_density(cls, density: float) -> float:
-        """Ensure connection_density is within [0, 1]."""
-        if not (0.0 <= density <= 1.0):
-            raise ValueError(f"connection_density must be in [0, 1], got {density}.")
-        return density
+        for a in acts:
+            if a not in ACTIVATIONS:
+                raise ValueError(
+                    f"Invalid activation function '{a}'. "
+                    f"Valid options are: {sorted(ACTIVATIONS.keys())}"
+                )
+        return acts

{evolib-0.2.0b4.dev8 → evolib-0.2.0b4.dev10}/evolib/config/vector_component_config.py

@@ -1,7 +1,14 @@
 # SPDX-License-Identifier: MIT
 from typing import Any, Literal, Optional, Tuple, Union
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    ValidationInfo,
+    field_validator,
+    model_validator,
+)
 
 from evolib.config.base_component_config import CrossoverConfig, MutationConfig
 from evolib.interfaces.enums import RepresentationType
@@ -21,7 +28,7 @@ class VectorComponentConfig(BaseModel):
             type: vector
             structure: flat              # "flat" | "net"
             dim: 16                      # or a list for structured cases
-            initializer: random_vector   # name from the initializer registry
+            initializer: normal          # name from the initializer registry
             bounds: [-1.0, 1.0]
             mutation:
               strategy: constant
@@ -86,7 +93,7 @@ class VectorComponentConfig(BaseModel):
     values: Optional[list[float]] = Field(
         default=None,
         description=(
-            "Explicit values for 'fixed_vector' initializer. If 'dim' is absent it "
+            "Explicit values for 'fixed' initializer. If 'dim' is absent it "
             "will be inferred from the length of 'values'."
         ),
     )
@@ -102,7 +109,6 @@ class VectorComponentConfig(BaseModel):
 
     # Evolution (mutation / crossover)
     mutation: MutationConfig = Field(
-        default=None,
         description=(
             "Mutation configuration. By default, 'probability' is an element-wise rate "
             "(per gene) in [0,1]; operators may optionally treat it as an apply gate."
@@ -143,18 +149,16 @@ class VectorComponentConfig(BaseModel):
     @classmethod
     def set_dim_for_fixed_vector(cls, config: dict[str, Any]) -> dict[str, Any]:
         """
-        If using 'fixed_vector', ensure 'values' is provided and infer 'dim' if absent.
+        If using 'fixed', ensure 'values' is provided and infer 'dim' if absent.
 
         This keeps YAML concise and catches common mistakes early.
         """
         initializer = config.get("initializer")
         values = config.get("values")
 
-        if initializer == "fixed_vector":
+        if initializer == "fixed":
             if not values:
-                raise ValueError(
-                    "When using 'fixed_vector', 'values' must be provided."
-                )
+                raise ValueError("When using 'fixed', 'values' must be provided.")
             if "dim" not in config:
                 config["dim"] = len(values)
         return config
@@ -181,3 +185,30 @@ class VectorComponentConfig(BaseModel):
         else:
             raise TypeError("dim must be an int or list of ints")
         return dim
+
+    @field_validator("initializer")
+    @classmethod
+    def validate_initializer(cls, name: str, info: ValidationInfo) -> str:
+        """Validate allowed initializer names and provide clear errors for deprecated
+        names."""
+        if not isinstance(name, str) or not name.strip():
+            raise ValueError("initializer must be a non-empty string")
+
+        name = name.strip()
+
+        allowed = {"normal", "uniform", "zero", "fixed", "adaptive"}
+        if name not in allowed:
+            raise ValueError(
+                f"Unknown initializer '{name}'. " f"Allowed: {sorted(allowed)}"
+            )
+
+        # structure-aware check (only if structure is available in the data)
+        data = info.data or {}
+        structure = data.get("structure") or "flat"
+        if structure == "net" and name != "normal":
+            raise ValueError(
+                "For structure='net', initializer must be 'normal' "
+                "(use initializer: normal and structure: net)."
+            )
+
+        return name

{evolib-0.2.0b4.dev8 → evolib-0.2.0b4.dev10}/evolib/initializers/evonet_initializers.py

@@ -14,7 +14,6 @@ from evonet.enums import ConnectionType, NeuronRole
 
 from evolib.config.evonet_component_config import DelayConfig, EvoNetComponentConfig
 from evolib.config.schema import FullConfig
-from evolib.interfaces.enum_helpers import resolve_recurrent_kinds
 from evolib.representation.evonet import EvoNet
 
 
@@ -158,14 +157,14 @@ def _build_architecture(
             dynamics_name = dynamics_cfg.name
             dynamics_params = dynamics_cfg.params or {}
 
-        recurrent_kinds = resolve_recurrent_kinds(cfg.recurrent)
+        allowed_kinds = set(cfg.connectivity.recurrent)
         para.net.add_neuron(
             count=num_neurons,
             activation=activation_name,
             role=role,
             connection_init=connection_init,
             bias=0.0,
-            recurrent=recurrent_kinds if role != NeuronRole.INPUT else None,
+            recurrent=allowed_kinds if role != NeuronRole.INPUT else None,
             connection_scope=para.connection_scope,
             connection_density=para.connection_density,
             dynamics_name=dynamics_name,