Spaces:
Sleeping
Sleeping
| """Deterministic genome mutation + crossover (REAL, IMPLEMENTED).""" | |
| import numpy as np | |
| from typing import Dict, Any, Tuple | |
| from src.genome.schema import Genome, PARAM_BOUNDS | |
| from src.common.determinism import derive_subseed | |
| MUTATION_CLASSES = ("parameter", "developmental", "plasticity", "metabolic", "behavioral") | |
| def _class_of_param(name: str) -> str: | |
| if name in ("neurogenesis_rate", "differentiation_bias", "migration_rate", | |
| "axon_growth_rate", "dendrite_growth_rate", "synaptogenesis_rate", | |
| "pruning_threshold", "developmental_timing", "growth_budget_fraction"): | |
| return "developmental" | |
| if name in ("plasticity_rate", "memory_retention", "eligibility_decay", | |
| "neuromod_novelty_weight", "neuromod_prediction_weight", | |
| "prediction_gain"): | |
| return "plasticity" | |
| if name in ("metabolism_rate", "reproduction_threshold"): | |
| return "metabolic" | |
| return "behavioral" | |
| def mutate_genome(parent: Genome, mutation_seed: int, rate: float = 0.3, | |
| scale: float = 0.1) -> Tuple[Genome, Dict[str, Any]]: | |
| """Deterministic per-parameter Gaussian mutation. Returns (child, record).""" | |
| parent.validate() | |
| parent_hash = parent.genome_hash() | |
| rng = np.random.RandomState(int(mutation_seed) % (2 ** 31)) | |
| child_params = dict(parent.params) | |
| mutations = [] | |
| for key in sorted(child_params): | |
| if rng.rand() < rate: | |
| lo, hi = PARAM_BOUNDS[key] | |
| old = float(child_params[key]) | |
| new = float(np.clip(old + rng.normal(0.0, scale * (hi - lo)), lo, hi)) | |
| child_params[key] = new | |
| mutations.append({"param": key, "class": _class_of_param(key), | |
| "old": round(old, 6), "new": round(new, 6)}) | |
| child = Genome(params=child_params, version=parent.version, | |
| lineage={"parent_hash": parent_hash, "mutation_seed": int(mutation_seed)}) | |
| child.validate() | |
| record = { | |
| "parent_genome_hash": parent_hash, | |
| "mutation_seed": int(mutation_seed), | |
| "mutation_type": "parameter_mutation", | |
| "mutations": mutations, | |
| "offspring_genome_hash": child.genome_hash(), | |
| } | |
| return child, record | |
| def crossover_genomes(a: Genome, b: Genome, seed: int, mode: str = "sexual") -> Tuple[Genome, Dict[str, Any]]: | |
| """Deterministic uniform crossover + light mutation. Asexual returns clone+mutation.""" | |
| a.validate(); b.validate() | |
| ha, hb = a.genome_hash(), b.genome_hash() | |
| if mode == "asexual": | |
| child, rec = mutate_genome(a, derive_subseed(seed, "asexual"), rate=0.2) | |
| rec.update({"mode": "asexual", "parent_a": ha, "parent_b": None}) | |
| child.lineage.update({"crossover": "asexual", "parents": [ha]}) | |
| return child, rec | |
| if mode != "sexual": | |
| raise ValueError(f"Unknown crossover mode: {mode}") | |
| rng = np.random.RandomState(int(seed) % (2 ** 31)) | |
| # Version policy: same versions -> child keeps that version; mixed | |
| # v1 x v2 -> child is v2 (architecture genes present via the v2 parent). | |
| child_version = a.version if a.version == b.version else "2.0" | |
| keys = sorted(set(a.params) | set(b.params)) | |
| child_params = {} | |
| choices = {} | |
| for key in keys: | |
| take_a = bool(rng.rand() < 0.5) | |
| primary, other = (a, b) if take_a else (b, a) | |
| # mixed-version safety: fall back to the parent that has the gene | |
| val = primary.params.get(key, other.params.get(key)) | |
| if val is None: | |
| from src.genome.schema import ARCH_PARAMS | |
| val = ARCH_PARAMS[key] | |
| child_params[key] = float(val) | |
| choices[key] = "A" if take_a else "B" | |
| child = Genome(params=child_params, version=child_version, | |
| lineage={"parents": [ha, hb], "crossover_seed": int(seed)}) | |
| # post-crossover light mutation for variation | |
| child, mut_rec = mutate_genome(child, derive_subseed(seed, "post-xover"), rate=0.1) | |
| child.lineage.update({"parents": [ha, hb], "crossover_seed": int(seed)}) | |
| rec = {"mode": "sexual", "parent_a": ha, "parent_b": hb, | |
| "choices": choices, "post_mutations": mut_rec["mutations"], | |
| "offspring_genome_hash": child.genome_hash(), "crossover_seed": int(seed)} | |
| return child, rec | |