Merge pull request #42 from renbytes/dev-toxicBerryRigorous

Experiment - Toxic Berry Simulation

Author: bordumb

Makefile

@@ -56,9 +56,12 @@ setup:
 
 ## run: Start Celery workers and run a full experiment.
 run:
-	@echo "👷 Starting $(WORKERS) Celery workers in the background..."
-	@docker compose up -d worker --scale worker=$(WORKERS)
-	@echo "▶️ Running experiment from: $(FILE)"
+	@echo "👷 Starting services and $(WORKERS) Celery workers..."
+	@docker compose up -d app worker --scale worker=$(WORKERS)
+	@echo "⏳ Waiting 5 seconds for services to initialize..."
+	@sleep 5
+	@echo "▶️ Submitting experiment from: $(FILE)"
+	# This command will now succeed because the 'app' container is running.
 	@docker compose exec app poetry run agentsim run-experiment $(FILE)
 
 ## run-local: Run a single, local simulation for quick testing and debugging.

agent-sim/src/agent_sim/infrastructure/tasks/celery_app.py

@@ -22,7 +22,19 @@
     )
 
 REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379/0")
-app = Celery("agent_sim", include=["agent_sim.infrastructure.tasks.simulation_tasks"])
+
+# --- MODIFIED: Explicitly list all modules containing tasks ---
+app = Celery(
+    "agent_sim",
+    include=[
+        "agent_sim.infrastructure.tasks.simulation_tasks",
+        # This ensures Celery is aware of the simulation's run module,
+        # which helps resolve import paths when the task is executed.
+        "simulations.berry_sim.run",
+        "simulations.schelling_sim.run",
+    ],
+)
+# --- END MODIFICATION ---
 
 app.conf.worker_pool_restarts = True
 app.conf.worker_pool = "prefork"

docker-compose.yml

@@ -51,8 +51,8 @@ services:
       - .env
     ports:
       - "5432:5432"
+    command: postgres -c 'max_connections=201'
     healthcheck:
-      # CORRECTED: Was misspelled as ${POSTGRAES_USER}
       test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
       interval: 10s
       timeout: 5s

simulations/berry_sim/actions.py

@@ -52,9 +52,11 @@ def execute(
     def get_feature_vector(
         self, entity_id: str, sim_state: SimulationState, params: Dict[str, Any]
     ) -> List[float]:
-        # Padded the vector to have a length of 4 to match EatBerryAction.
-        # The schema is now [is_move, is_eat_red, is_eat_blue, is_eat_yellow]
-        return [1.0, 0.0, 0.0, 0.0]
+        """
+        Generates the feature vector for a move action.
+        Schema: [is_move, is_eat_red, is_eat_blue, is_eat_yellow, is_eat_orange]
+        """
+        return [1.0, 0.0, 0.0, 0.0, 0.0]
 
 
 @action_registry.register
@@ -100,11 +102,15 @@ def execute(
     def get_feature_vector(
         self, entity_id: str, sim_state: SimulationState, params: Dict[str, Any]
     ) -> List[float]:
+        """
+        Generates the one-hot encoded feature vector for eating a specific berry.
+        Schema: [is_move, is_eat_red, is_eat_blue, is_eat_yellow, is_eat_orange]
+        """
         berry_type = params.get("berry_type", "")
-        # The schema is [is_move, is_eat_red, is_eat_blue, is_eat_yellow]
         return [
             0.0,
             1.0 if berry_type == "red" else 0.0,
             1.0 if berry_type == "blue" else 0.0,
             1.0 if berry_type == "yellow" else 0.0,
+            1.0 if berry_type == "orange" else 0.0,
         ]

simulations/berry_sim/components.py

@@ -44,17 +44,31 @@ def validate(self, entity_id: str) -> Tuple[bool, List[str]]:
         return True, []
 
 
+class MetabolicBoostComponent(Component):
+    """Tracks the status of a temporary metabolic boost for an agent."""
+
+    def __init__(self, active: bool = False, ticks_remaining: int = 0):
+        self.active = active
+        self.ticks_remaining = ticks_remaining
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"active": self.active, "ticks_remaining": self.ticks_remaining}
+
+    def validate(self, entity_id: str) -> Tuple[bool, List[str]]:
+        return True, []
+
+
 class BerryComponent(Component):
     """Represents a berry resource in the environment."""
 
     def __init__(self, berry_type: str) -> None:
-        self.berry_type = berry_type  # "red", "blue", or "yellow"
+        self.berry_type = berry_type  # "red", "blue", "yellow", or "orange"
 
     def to_dict(self) -> Dict[str, Any]:
         return {"berry_type": self.berry_type}
 
     def validate(self, entity_id: str) -> Tuple[bool, List[str]]:
-        if self.berry_type not in ["red", "blue", "yellow"]:
+        if self.berry_type not in ["red", "blue", "yellow", "orange"]:
             return False, [f"Invalid berry type: {self.berry_type}"]
         return True, []
 
@@ -77,3 +91,13 @@ def to_dict(self) -> Dict[str, Any]:
 
     def validate(self, entity_id: str) -> Tuple[bool, List[str]]:
         return True, []
+
+
+class PurifierCrystalComponent(Component):
+    """A marker component for a purifier crystal tile."""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {}
+
+    def validate(self, entity_id: str) -> Tuple[bool, List[str]]:
+        return True, []

simulations/berry_sim/config/config.yml

@@ -6,7 +6,6 @@ simulation:
   steps: 1600
   log_directory: "data/logs/berry_sim"
   random_seed: 42
-  # Default to disabled; the experiment file will enable it for the causal agent.
   enable_causal_system: false
 
 environment:
@@ -15,11 +14,14 @@ environment:
     width: 50
     height: 50
   spawning:
-    red_rate: 1.0
-    blue_rate: 0.75
-    yellow_rate: 0.75
+    red_rate: 0.20
+    blue_rate: 0.15
+    yellow_rate: 0.15
+    orange_rate: 0.10 # For Experiment 3
+    purifier_crystal_count: 7 # For Experiment 2
 
 agent:
+  vision_range: 7
   vitals:
     initial_health: 100.0
   # Dummy values since these schemas are required by the base config
@@ -48,20 +50,20 @@ learning:
   q_learning:
     alpha: 0.1
     gamma: 0.95
-    initial_epsilon: 0.1
+    initial_epsilon: 1.0
+    epsilon_decay_rate: 0.995
+    min_epsilon: 0.01
   memory:
     reflection_interval: 100
 
 scenario_loader:
-  # CORRECTED: Was pointing to the Schelling loader
   class: "simulations.berry_sim.loader.BerryScenarioLoader"
 
 action_generator:
   class: "simulations.berry_sim.providers.BerryActionGenerator"
 
 decision_selector:
-  # Default to the simple heuristic selector for the baseline.
-  class: "simulations.berry_sim.providers.BerryDecisionSelector"
+  class: "simulations.berry_sim.providers.HeuristicDecisionSelector"
 
 component_factory:
   class: "simulations.berry_sim.providers.BerryComponentFactory"
@@ -85,5 +87,5 @@ logging:
 rendering:
   enabled: true
   output_directory: "data/gif_renders/berry_sim"
-  frames_per_second: 1
+  frames_per_second: 15
   pixel_scale: 10

simulations/berry_sim/environment.py

@@ -16,28 +16,44 @@ def __init__(self, width: int, height: int) -> None:
         self.height = height
         self.water_locations: Set[Tuple[int, int]] = set()
         self.rock_locations: Set[Tuple[int, int]] = set()
+        self.crystal_locations: Set[Tuple[int, int]] = set()
         self.berry_locations: Dict[Tuple[int, int], str] = {}
         self.agent_positions: Dict[str, Tuple[int, int]] = {}
         self._grid_entities: Dict[Tuple[int, int], str] = {}
 
     def is_occupied(self, position: Tuple[int, int]) -> bool:
-        """Check if a cell is occupied by a blocking object (agent, rock, water)."""
+        """Check if a cell is occupied by a blocking object."""
         return (
             position in self._grid_entities
             or position in self.water_locations
             or position in self.rock_locations
+            or position in self.crystal_locations
         )
 
     def get_random_empty_cell(self) -> Optional[Tuple[int, int]]:
-        """Finds a random unoccupied cell."""
-        for _ in range(self.width * self.height):  # Avoid infinite loops
-            pos = (
-                random.randint(0, self.width - 1),
-                random.randint(0, self.height - 1),
-            )
-            if not self.is_occupied(pos) and pos not in self.berry_locations:
-                return pos
-        return None
+        """
+        Finds a random unoccupied cell.
+
+        This implementation is deterministic in finding all empty cells and will
+        not fail if only one empty cell remains.
+        """
+        # Changed from a probabilistic search to a deterministic one.
+        # This guarantees finding an empty cell if one exists.
+        occupied_cells = (
+            self.water_locations
+            | self.rock_locations
+            | self.crystal_locations
+            | set(self.berry_locations.keys())
+            | set(self.agent_positions.values())
+        )
+
+        all_cells = set((x, y) for x in range(self.width) for y in range(self.height))
+        empty_cells = list(all_cells - occupied_cells)
+
+        if not empty_cells:
+            return None
+
+        return random.choice(empty_cells)
 
     def get_berry_toxicity(
         self, berry_type: str, position: Tuple[int, int], tick: int
@@ -46,16 +62,19 @@ def get_berry_toxicity(
         if berry_type == "red":
             return 10.0
         elif berry_type == "blue":
-            return (
-                -20.0
-                if self.is_near_feature(position, self.water_locations, 2)
-                else 10.0
-            )
+            is_near_water = self.is_near_feature(position, self.water_locations, 2)
+            is_near_crystal = self.is_near_feature(position, self.crystal_locations, 2)
+            if is_near_crystal:
+                return 10.0  # Crystals purify blue berries
+            if tick >= 1000 and is_near_water:
+                return -20.0  # Toxic after tick 1000 if near water
+            return 10.0
         elif berry_type == "yellow":
-            # Toxicity is random, but seeded by position and tick for reproducibility
-            seed = hash((position, tick // 100))  # Stable toxicity for a period
+            seed = hash((position, tick // 100))
             rng = random.Random(seed)
             return -20.0 if rng.random() < 0.5 else 10.0
+        elif berry_type == "orange":
+            return 5.0  # Small direct health boost, main effect is metabolic
         return 0.0
 
     def is_near_feature(
@@ -73,6 +92,7 @@ def get_environmental_context(self, position: Tuple[int, int]) -> Dict[str, bool
         return {
             "near_water": self.is_near_feature(position, self.water_locations, 2),
             "near_rocks": self.is_near_feature(position, self.rock_locations, 2),
+            "near_crystal": self.is_near_feature(position, self.crystal_locations, 2),
         }
 
     # --- Interface Methods ---
@@ -123,18 +143,22 @@ def is_valid_position(self, position: Any) -> bool:
         return 0 <= position[0] < self.width and 0 <= position[1] < self.height
 
     def get_entities_in_radius(self, center: Any, radius: int) -> List[Tuple[str, Any]]:
-        return []  # Not needed for this simulation
+        return []
 
     def to_dict(self) -> Dict[str, Any]:
         return {
             "width": self.width,
             "height": self.height,
             "water_locations": [list(pos) for pos in self.water_locations],
             "rock_locations": [list(pos) for pos in self.rock_locations],
+            "crystal_locations": [list(pos) for pos in self.crystal_locations],
         }
 
     def restore_from_dict(self, data: Dict[str, Any]) -> None:
         self.width = data["width"]
         self.height = data["height"]
-        self.water_locations = {tuple(pos) for pos in data["water_locations"]}
-        self.rock_locations = {tuple(pos) for pos in data["rock_locations"]}
+        self.water_locations = {tuple(pos) for pos in data.get("water_locations", [])}
+        self.rock_locations = {tuple(pos) for pos in data.get("rock_locations", [])}
+        self.crystal_locations = {
+            tuple(pos) for pos in data.get("crystal_locations", [])
+        }

simulations/berry_sim/experiments/causal_ab_test.yml

@@ -1,6 +1,6 @@
 # simulations/berry_sim/experiments/causal_ab_test.yml
 
-experiment_name: "Berry Sim - Causal Agent A/B Test"
+experiment_name: "Exp1 - Isolating Causal Reasoning"
 
 base_config_path: "simulations/berry_sim/config/config.yml"
 
@@ -9,24 +9,40 @@ simulation_package: "simulations.berry_sim"
 scenarios:
   - "simulations/berry_sim/scenarios/default.json"
 
-# Run each variation 3 times for statistical significance
-runs_per_scenario: 3
+# Run each variation 50 times for statistical power
+runs_per_scenario: 50
 
 variations:
-  - name: "Baseline-Heuristic-Agent"
+  - name: "GroupA-Heuristic-Baseline"
     overrides:
       simulation:
-        # Explicitly disable the causal system for the baseline
         enable_causal_system: false
       decision_selector:
-        # Use the simple, hard-coded heuristic policy
-        class: "simulations.berry_sim.providers.BerryDecisionSelector"
+        # Simple rule-based agent with perfect environmental knowledge
+        class: "simulations.berry_sim.providers.HeuristicDecisionSelector"
 
-  - name: "Causal-QLearning-Agent"
+  - name: "GroupB-Full-Causal-Model"
     overrides:
       simulation:
-        # Enable the causal system for the advanced agent
+        # The full cognitive model with causal reasoning enabled
         enable_causal_system: true
       decision_selector:
-        # Use the new, intelligent policy that queries the neural network
+        # Q-learning agent that uses the causal system's output
         class: "simulations.berry_sim.providers.QLearningDecisionSelector"
+
+  - name: "GroupC-Perception-Only-Control"
+    overrides:
+      simulation:
+        # Causal reasoning is turned off for this control group
+        enable_causal_system: false
+      decision_selector:
+        # Standard Q-learning agent without causal feedback
+        class: "simulations.berry_sim.providers.QLearningDecisionSelector"
+
+  - name: "GroupD-Exploration-Matched-Heuristic"
+    overrides:
+      simulation:
+        enable_causal_system: false
+      decision_selector:
+        # Rule-based agent with exploration to match the Q-learning agents
+        class: "simulations.berry_sim.providers.ExplorationHeuristicDecisionSelector"

simulations/berry_sim/experiments/validate_perception.yml

@@ -0,0 +1,31 @@
+# simulations/berry_sim/experiments/validate_perception.yml
+
+experiment_name: "Exp2 - Validating Agent Perception"
+
+base_config_path: "simulations/berry_sim/config/config.yml"
+
+simulation_package: "simulations.berry_sim"
+
+scenarios:
+  - "simulations/berry_sim/scenarios/default.json"
+
+# Run only a few times for a quick check
+runs_per_scenario: 2
+
+variations:
+  - name: "QLearning-Agent-With-Vision"
+    overrides:
+      # We want to test the full cognitive model with perception
+      simulation:
+        enable_causal_system: true
+      agent:
+        # Let's make the simulation smaller and faster for this test
+        foundational:
+          num_agents: 25
+        vision_range: 7 # Make sure vision is on
+      environment:
+        params:
+          width: 25
+          height: 25
+      decision_selector:
+        class: "simulations.berry_sim.providers.QLearningDecisionSelector"