fix score range

baseline_scores.json

@@ -1,8 +1,8 @@
 {
   "scores": {
-    "task1": 0.999,
-    "task2": 0.999,
-    "task3": 0.999
+    "task1": 0.99,
+    "task2": 0.99,
+    "task3": 0.99
   },
-  "average": 0.999
+  "average": 0.9899999999999999
 }

inference.py

@@ -11,7 +11,7 @@ Required environment variables:
 STDOUT FORMAT (OpenEnv spec):
     [START] task=<task_name> env=<benchmark> model=<model_name>
     [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
-    [END]   success=<true|false> steps=<n> rewards=<r1,r2,...,rn>
+    [END]   task=<task_name> score=<0.00> steps=<n>
 """
 
 import json
@@ -90,9 +90,12 @@ def log_step(step: int, action: str, reward: float, done: bool, error: Optional[
     )
 
 
-def log_end(success: bool, steps: int, rewards: List[float]) -> None:
-    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
-    print(f"[END] success={str(success).lower()} steps={steps} rewards={rewards_str}", flush=True)
+def log_end(task_name: str, score: float, steps: int) -> None:
+    safe_score = max(0.01, min(0.99, float(score)))
+    print(
+        f"[END] task={task_name} score={safe_score:.4f} steps={steps}",
+        flush=True
+    )
 
 
 # ------------------------------------------------------------------
@@ -112,23 +115,6 @@ def api_get(path: str) -> dict:
     resp.raise_for_status()
     return resp.json()
 
-# ------------------------------------------------------------------
-# Score sanitizer
-# ------------------------------------------------------------------
-
-def sanitize_score(score: float) -> float:
-    """
-    Ensures score is strictly within (0, 1)
-    required by hackathon validator.
-    """
-    EPS = 1e-4
-
-    if score >= 1.0:
-        return 1.0 - EPS
-    if score <= 0.0:
-        return EPS
-
-    return float(score)
 
 # ------------------------------------------------------------------
 # Agent loop
@@ -243,9 +229,10 @@ def run_task(task_id: int) -> float:
             time.sleep(0.3)
 
     finally:
-        log_end(success=success, steps=steps_taken, rewards=rewards)
+        final = obs.get("current_score", 0.01) if isinstance(obs, dict) else 0.01
+        log_end(task_name=task_name, score=final, steps=steps_taken)
 
-    final_score = sanitize_score(obs["current_score"])
+    final_score = obs["current_score"]
     print(
         f"\n  Task {task_id} final score: {final_score:.4f}  (steps used: {obs['step_count']})",
         file=sys.stderr,
@@ -278,14 +265,14 @@ def main():
             scores[f"task{task_id}"] = run_task(task_id)
         except Exception as exc:
             print(f"[ERROR] Task {task_id} failed: {exc}", file=sys.stderr)
-            scores[f"task{task_id}"] = 0.0
+            scores[f"task{task_id}"] = 0.01
 
     print("\n" + "="*60, file=sys.stderr)
     print("  BASELINE RESULTS", file=sys.stderr)
     print("="*60, file=sys.stderr)
     for k, v in scores.items():
         print(f"  {k}: {v:.4f}", file=sys.stderr)
-    avg = sanitize_score(sum(scores.values()) / len(scores))
+    avg = sum(scores.values()) / len(scores)
     print(f"  average: {avg:.4f}", file=sys.stderr)
     print("="*60, file=sys.stderr)
 

server/environment.py

@@ -33,7 +33,7 @@ class DataCleaningEnvironment:
         self._step_count: int               = 0
         self._max_steps: int                = 20
         self._total_errors: int             = 0
-        self._last_score: float             = 0.001
+        self._last_score: float             = 0.01
         self._task_cycle: int               = 0      # for round-robin default
 
     # ------------------------------------------------------------------
@@ -78,16 +78,16 @@ class DataCleaningEnvironment:
 
         delta = score_after - score_before
         if not applied:
-            reward = 0.001
+            reward = 0.01
         elif delta <= 0:
-            reward = 0.001
+            reward = 0.01
         else:
             reward = round(delta, 4)
 
         done = (score_after >= 0.95) or (self._step_count >= self._max_steps)
 
-        # Clamp reward strictly within (0.001, 0.999) — no terminal bonus
-        reward = round(max(0.001, min(0.999, reward)), 4)
+        # Clamp reward strictly within (0.01, 0.99) — no terminal bonus
+        reward = round(max(0.01, min(0.99, reward)), 4)
 
         return self._build_obs(reward, done, message)
 

server/tasks/task1_missing.py

@@ -30,9 +30,9 @@ def load():
 def score(current_df, original_nulls: int) -> float:
     """Score in [0, 1]: fraction of nulls filled."""
     if original_nulls == 0:
-        return 0.999
+        return 0.99
     remaining = int(current_df.isnull().sum().sum())
-    return round(max(0.001, min(0.999, 1.0 - remaining / original_nulls)), 4)
+    return round(max(0.01, min(0.99, 1.0 - remaining / original_nulls)), 4)
 
 
 def count_errors(current_df) -> int:

server/tasks/task2_format.py

@@ -56,7 +56,7 @@ def score(current_df, meta: dict) -> float:
     dupe_score  = 1.0 - dupes        / max(meta["orig_dupes"], 1)
 
     combined = 0.35 * phone_score + 0.35 * date_score + 0.30 * dupe_score
-    return round(max(0.001, min(0.999, combined)), 4)
+    return round(max(0.01, min(0.99, combined)), 4)
 
 
 def count_errors(current_df, meta: dict) -> int:

server/tasks/task3_pipeline.py

@@ -87,7 +87,7 @@ def score(current_df, meta: dict) -> float:
 
     combined = 0.25 * null_score + 0.20 * dupe_score + 0.20 * outlier_score \
              + 0.175 * country_score + 0.175 * date_score
-    return round(max(0.001, min(0.999, combined)), 4)
+    return round(max(0.01, min(0.99, combined)), 4)
 
 
 def count_errors(current_df, meta: dict) -> int: