Swap grader weights: hospital=45% primary constraint, containment=30%, calibrate environment

.env

@@ -0,0 +1,4 @@
+HF_TOKEN=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
+API_BASE_URL=https://api.groq.com/openai/v1
+MODEL_NAME=llama-3.1-8b-instant
+ENV_BASE_URL=https://therubberduckdebuggers-cascade-containment.hf.space

baseline/evaluator.py

@@ -125,7 +125,7 @@ def run_task_grpo(
 
         total_reward, steps, trajectory = run_rollout(env, task_name, client, memory, verbose)
 
-        # Use real grader score from server
+        # Get proper grader score from server
         num_districts = {"easy": 2, "medium": 4, "hard": 6}.get(task_name, 2)
         try:
             grade_resp = http_requests.get(
@@ -146,20 +146,26 @@ def run_task_grpo(
         except Exception:
             score = normalise_score(total_reward, steps, num_districts)
 
-        # GRPO advantage computation
+        # Append BEFORE advantage computation
+        rollouts.append((total_reward, steps, score))
+
+        if verbose:
+            print(f"    → Reward: {total_reward:+.4f} | Score: {score:.4f}")
+
+        # ── GRPO advantage computation and memory update ──────────────────────
         completed_rewards = [r[0] for r in rollouts]
         advantage         = compute_advantage(total_reward, completed_rewards[:-1])
         stored            = update_memory(memory, trajectory, advantage)
 
         if verbose:
             mean = sum(completed_rewards[:-1]) / max(len(completed_rewards) - 1, 1) \
-                   if len(completed_rewards) > 1 else total_reward
+                if len(completed_rewards) > 1 else total_reward
             print(f"    → Advantage: {advantage:+.4f} | "
-                  + (f"↑ Stored {stored} steps" if stored > 0 else "↓ Suppressed"))
+                + (f"↑ Stored {stored} steps" if stored > 0 else "↓ Suppressed"))
 
     all_rewards = [r[0] for r in rollouts]
     mean_reward = sum(all_rewards) / len(all_rewards)
-    best_score  = max(rollouts, key=lambda x: x[0])[2]
+    best_score = max(rollouts, key=lambda x: x[2])[2]
 
     if verbose:
         print(f"\n  Rewards:    {[round(r, 4) for r in all_rewards]}")

core/policy_update.py

@@ -32,7 +32,7 @@ def should_reinforce(advantage: float) -> bool:
     Reinforce if advantage >= 0 (at or above mean).
     Suppress if below mean.
     """
-    return advantage >= 0
+    return advantage > -0.5  # allow small negative margin to encourage exploration
 
 
 def update_memory(

core/reward.py

@@ -5,16 +5,14 @@
 
 import math
 
-
-def normalise_score(total_reward: float, steps: int) -> float:
+def normalise_score(total_reward: float, steps: int, num_districts: int = 2) -> float:
     """
-    Map cumulative reward to [0.0, 1.0] via sigmoid on average reward per step.
-    Guaranteed to always return a value strictly within the valid range.
-
-    Average reward of 0   → 0.5
-    Positive average      → above 0.5
-    Negative average      → below 0.5
+    Linear normalization with task-aware worst case.
+    Worst case per step = num_districts × (-0.5 infection) + num_districts × (-1.0 breach)
+    Best case per step = num_districts × (+0.5 containment) + 0.30 prioritisation
     """
-    raw   = total_reward / max(steps, 1)
-    score = 1.0 / (1.0 + math.exp(-raw))
+    avg   = total_reward / max(steps, 1)
+    worst = num_districts * (-1.5)   # -0.5 infection + -1.0 breach per district
+    best  = num_districts * (0.5) + 0.3
+    score = (avg - worst) / (best - worst)
     return round(min(1.0, max(0.0, score)), 4)

core/trajectory.py

@@ -29,7 +29,7 @@ class EpisodicMemory:
 
     def store(self, obs: CityObservation, action: ContainmentAction, reward: float):
         """Store a step only if it earned positive reward."""
-        if reward <= 0:
+        if reward < -0.3:
             return
 
         self.memories.append({

server/grader.py

@@ -172,8 +172,8 @@ def grade_trajectory(
     #   speed       = tiebreaker
 
     final_score = (
-        containment_score  * 0.45 +
-        hospital_score     * 0.30 +
+        containment_score  * 0.30 +
+        hospital_score     * 0.45 +
         efficiency_score   * 0.15 +
         speed_score        * 0.10
     )