Added eps

graders.py

@@ -4,75 +4,66 @@ from typing import Any, Dict
 
 from .tasks import TASK_REGISTRY, Task
 
-_EPS = 1e-6  # keeps scores strictly inside (0, 1) as required by the platform
+_EPS = 1e-3  # keeps every score in the open interval (0, 1)
 
 
-class ManufacturingTaskGrader:
-    """Discriminating scorer for a completed episode.
+def _clamp(value: float) -> float:
+    """Clamp *value* to the open interval (0, 1) exclusive."""
+    return max(_EPS, min(1.0 - _EPS, value))
 
-    Sub-scores:
-      1. on_time_delivery_rate  — on_time_deliveries / total delivery windows
-      2. reward_efficiency      — total_reward / task.target_reward
-      3. assembly_rate          — assemblies_completed / total assembly orders (if any)
-      4. energy_health          — mean final energy / ENERGY_MAX (100)
-      5. invalid_action_penalty — 1 - invalid_actions / max_invalid_actions
 
-    Weights: delivery × 3, reward_efficiency × 2, assembly × 1.5, energy × 1, penalty × 1
-    """
+class ManufacturingTaskGrader:
+    """Deterministic 0.0–1.0 scorer for a completed episode."""
 
     def __init__(self, task_name: str) -> None:
         if task_name not in TASK_REGISTRY:
             raise ValueError(f"Unknown task '{task_name}'.")
         self.task: Task = TASK_REGISTRY[task_name]
 
-    def grade(
-        self,
-        metrics: Dict[str, Any],
-        step_count: int,
-        platforms: list,
-        total_reward: float = 0.0,
-    ) -> float:
+    def grade(self, metrics: Dict[str, Any], step_count: int, platforms: list) -> float:
         t = self.task
 
-        # 1. On-time delivery rate  (naturally ≤ 1 since windows are removed on match)
-        total_windows = len(t.delivery_windows)
-        on_time = metrics.get("on_time_deliveries", 0)
-        delivery_score = min(1.0, on_time / max(total_windows, 1))
-
-        # 2. Reward efficiency  (cap at 1.0; target_reward sits above empirical perfect)
-        reward_score = min(1.0, total_reward / t.target_reward)
+        # 1. Production runs
+        prod_score = _clamp(
+            min(1.0, metrics.get("production_runs", 0) / max(t.min_production_runs, 1))
+        )
 
-        # 3. Assembly rate (only for tasks with assembly orders)
-        total_assemblies = sum(1 for o in t.pending_orders if o.requires_assembly)
-        if total_assemblies > 0:
-            asm_score = min(1.0, metrics.get("assemblies_completed", 0) / total_assemblies)
+        # 2. Assemblies (skip if not required)
+        if t.min_assemblies > 0:
+            asm_score = _clamp(
+                min(1.0, metrics.get("assemblies_completed", 0) / t.min_assemblies)
+            )
         else:
             asm_score = None
 
-        # 4. Energy health  —  mean final energy / 100  (capped at 1.0)
-        energy_score = min(1.0, (
-            sum(p.energy for p in platforms) / (100.0 * len(platforms))
-            if platforms else 0.0
-        ))
+        # 3. Deliveries
+        del_score = _clamp(
+            min(1.0, metrics.get("deliveries_completed", 0) / max(t.min_deliveries, 1))
+        )
+
+        # 4. Energy health (average final energy across platforms)
+        if platforms:
+            avg_energy = sum(p.energy for p in platforms) / len(platforms)
+        else:
+            avg_energy = 0.0
+        energy_score = _clamp(min(1.0, avg_energy / max(t.min_energy_final, 1.0)))
 
-        # 5. Invalid-action penalty
+        # 5. Invalid-action penalty (1.0 = no invalids, 0.0 = at or above max)
         inv = metrics.get("invalid_actions", 0)
         if t.max_invalid_actions > 0:
-            invalid_penalty = max(0.0, 1.0 - inv / t.max_invalid_actions)
+            invalid_penalty = _clamp(max(0.0, 1.0 - inv / t.max_invalid_actions))
         else:
-            invalid_penalty = 1.0 if inv == 0 else 0.0
+            invalid_penalty = _clamp(1.0 if inv == 0 else 0.0)
 
         # Weighted average
-        weights = [3.0, 2.0, 1.0, 1.0]
-        scores  = [delivery_score, reward_score, energy_score, invalid_penalty]
+        scores = [prod_score, del_score, energy_score, invalid_penalty]
         if asm_score is not None:
-            weights.append(1.5)
             scores.append(asm_score)
 
-        base_score = sum(w * s for w, s in zip(weights, scores)) / sum(weights)
+        base_score = sum(scores) / len(scores)
 
         # Over-steps penalty
         if step_count > t.max_steps:
             base_score *= 0.8
 
-        return max(_EPS, min(1.0 - _EPS, base_score))
+        return _clamp(round(base_score, 4))

inference.py

@@ -119,6 +119,13 @@ TASK_TYPES      = {"easy": EasyTask, "medium": MediumTask, "hard": HardTask}
 VALID_ACTIONS   = {"produce", "assemble", "deliver", "recharge"}
 ACTION_PATTERN  = re.compile(r"(produce|assemble|deliver|recharge)", re.IGNORECASE)
 
+_SCORE_EPS = 1e-9  # keeps every score strictly inside (0, 1)
+
+
+def _clamp_score(value: float) -> float:
+    """Clamp *value* to the open interval (0, 1) exclusive."""
+    return max(_SCORE_EPS, min(1.0 - _SCORE_EPS, float(value)))
+
 # ── system prompt ──────────────────────────────────────────────────────────────
 SYSTEM_PROMPT = textwrap.dedent("""
     You are controlling orbital manufacturing platforms.
@@ -491,7 +498,7 @@ async def run_task(task_name: str, client: Optional[Any]) -> TaskRunResult:
 
     final_state = env.state()
     metrics     = {k: float(v) for k, v in final_state.metrics.items()}
-    score = grader.grade(metrics, final_state.step_count, final_state.platforms, final_state.total_reward)
+    score       = _clamp_score(grader.grade(metrics, final_state.step_count, final_state.platforms))
 
     print(
         f"[END]   task={task_name} score={score:.4f}"

tasks.py

@@ -23,11 +23,6 @@ class Task(ABC):
     min_energy_final: float
     max_invalid_actions: int
 
-    # Reward ceiling used by the grader — set above the empirical perfect score
-    # so that reward_score = total_reward / target_reward < 1.0 even for a
-    # flawless run, giving continuous signal instead of a hard cap.
-    target_reward: float
-
 
 class EasyTask(Task):
     name = "easy"
@@ -55,7 +50,6 @@ class EasyTask(Task):
     min_deliveries = 2
     min_energy_final = 40.0
     max_invalid_actions = 3
-    target_reward = 260.0   # ~12% above empirical perfect (231.50)
 
 
 class MediumTask(Task):
@@ -101,7 +95,6 @@ class MediumTask(Task):
     min_deliveries = 6
     min_energy_final = 25.0
     max_invalid_actions = 8
-    target_reward = 800.0   # ~12% above empirical perfect (712.80)
 
 
 class HardTask(Task):
@@ -178,7 +171,6 @@ class HardTask(Task):
     min_deliveries = 14
     min_energy_final = 15.0
     max_invalid_actions = 12
-    target_reward = 1900.0  # ~12% above empirical perfect (1704.40)
 
 
 TASK_REGISTRY: Dict[str, Task] = {