Update evo_architecture.py

evo_architecture.py

@@ -3,49 +3,71 @@
 import random
 import json
 import os
+import uuid
+import csv
 
 GENOME_LOG = "genome_log.csv"
+BEST_GENOME_FILE = "best_genome.json"
 
-def mutate_genome(base_config):
-    """Randomly mutates one architectural parameter from the base config."""
-    new_config = base_config.copy()
+# Mutation bounds
+MUTATION_LIMITS = {
+    "num_layers": (2, 12),
+    "ffn_dim": (256, 4096),
+    "num_heads": (2, 16),
+}
 
-    mutation_type = random.choice(["layers", "ffn_dim", "num_heads", "memory_enabled"])
+def default_config():
+    return {
+        "genome_id": str(uuid.uuid4()),
+        "num_layers": 6,
+        "ffn_dim": 1024,
+        "num_heads": 8,
+        "memory_enabled": True
+    }
+
+def mutate_genome(base_config, exploration_rate=0.5):
+    """Mutates the genome. Exploration rate controls how wild the mutation is (0 = minor, 1 = wild)."""
+    config = base_config.copy()
+    config["genome_id"] = str(uuid.uuid4())
+
+    # Select mutation type
+    mutation_type = random.choice(["num_layers", "ffn_dim", "num_heads", "memory_enabled"])
 
-    if mutation_type == "layers":
-        new_config["num_layers"] = max(2, min(8, new_config["num_layers"] + random.choice([-1, 1])))
-    elif mutation_type == "ffn_dim":
-        new_config["ffn_dim"] = max(256, min(2048, new_config["ffn_dim"] + random.choice([-256, 256])))
-    elif mutation_type == "num_heads":
-        new_config["num_heads"] = max(2, min(12, new_config["num_heads"] + random.choice([-2, 2])))
-    elif mutation_type == "memory_enabled":
-        new_config["memory_enabled"] = not new_config["memory_enabled"]
+    if mutation_type == "memory_enabled":
+        config["memory_enabled"] = not config["memory_enabled"]
+    else:
+        min_val, max_val = MUTATION_LIMITS[mutation_type]
+        change = int((max_val - min_val) * exploration_rate)
+        delta = random.randint(-change, change)
+        config[mutation_type] = max(min_val, min(max_val, config[mutation_type] + delta))
 
-    return new_config
+    return config
 
-def log_genome(config, performance=None):
-    """Logs the evolved genome and its score."""
-    header = ["num_layers", "ffn_dim", "num_heads", "memory_enabled", "score"]
+def log_genome(config, score=None):
+    """Logs genome config + performance to CSV."""
     row = [
+        config.get("genome_id", ""),
         config["num_layers"],
         config["ffn_dim"],
         config["num_heads"],
         config["memory_enabled"],
-        performance if performance is not None else ""
+        score if score is not None else ""
     ]
-
     file_exists = os.path.exists(GENOME_LOG)
-    with open(GENOME_LOG, "a", newline='', encoding='utf-8') as f:
-        import csv
+    with open(GENOME_LOG, "a", newline="", encoding="utf-8") as f:
         writer = csv.writer(f)
         if not file_exists:
-            writer.writerow(header)
+            writer.writerow(["genome_id", "num_layers", "ffn_dim", "num_heads", "memory_enabled", "score"])
         writer.writerow(row)
 
-def default_config():
-    return {
-        "num_layers": 6,
-        "ffn_dim": 1024,
-        "num_heads": 8,
-        "memory_enabled": True
-    }
+def save_best_genome(config):
+    """Saves the best-performing genome to file."""
+    with open(BEST_GENOME_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f)
+
+def load_best_genome():
+    """Loads best-performing genome (if exists), else default."""
+    if os.path.exists(BEST_GENOME_FILE):
+        with open(BEST_GENOME_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return default_config()