Upload folder using huggingface_hub

README.md

@@ -132,10 +132,70 @@ Each step returns:
 
 ## Scoring
 
-Final score (0-1) is weighted:
-- **Fraud detection accuracy** (50%) — Correct flags with right fraud type
-- **Detection timeliness** (30%) — How early fraud was caught
-- **Investigation efficiency** (20%) — Budget usage and false positive avoidance
+### Step Reward
+
+Every action returns an immediate reward in **[0, 1]**, centered at 0.5 (neutral).
+
+| Action | Condition | Reward |
+|--------|-----------|--------|
+| `monitor` | No active fraud | 0.50 |
+| `monitor` | Active unflagged fraud | 0.40 → 0.20 (penalty grows day over day) |
+| `investigate_publisher` | Publisher is fraudulent | 0.55 → 0.65 (bonus for investigating early) |
+| `investigate_publisher` | Publisher is clean | 0.35 (wastes budget) |
+| `flag_fraud` | Correct publisher + correct fraud type | 0.95 → 1.00 (bonus for early flag) |
+| `flag_fraud` | Correct publisher, wrong fraud type | 0.70 |
+| `flag_fraud` | False positive | 0.05 |
+| `submit_report` | Any | 0.50 |
+| Invalid / malformed action | — | 0.05 |
+
+The monitor penalty formula: `0.50 - (0.10 + 0.20 × day/14)`, floored at 0.05. On day 1 the penalty is ~0.10; by day 14 it reaches ~0.30, reflecting increasing urgency as fraud compounds.
+
+### Final Score
+
+Computed at episode end, combining three weighted components into a score in **[0, 1]**:
+
+```
+final_score = 0.50 × accuracy + 0.30 × timeliness + 0.20 × efficiency
+```
+
+#### 1. Fraud Detection Accuracy (50%)
+
+Measures whether fraudulent publishers were correctly identified with the right fraud type.
+
+- **+1.0 / N** per fraudster flagged with the correct fraud type
+- **+0.5 / N** per fraudster flagged with the wrong fraud type
+- **−0.5 / N** per false positive (clean publisher flagged as fraudulent)
+
+Clamped to [0, 1].
+
+#### 2. Detection Timeliness (30%)
+
+Measures how quickly each fraudster was caught after fraud began.
+
+```
+timeliness = 1.0 − (day_flagged − fraud_start_day) / (14 − fraud_start_day)
+```
+
+- Flagging immediately when fraud starts → 1.0
+- Flagging on the final day → 0.0
+- Unflagged fraudster → 0.0
+- Averaged across all fraudsters.
+
+#### 3. Investigation Efficiency (20%)
+
+Measures whether investigations were targeted at real fraudsters without wasting budget.
+
+```
+efficiency = 0.5 × (useful_investigations / total_investigations)
+           + 0.3 × (1 − budget_used / budget_total)
+           − 0.2 × num_false_positives
+```
+
+- **Information value** — fraction of investigations spent on fraudulent publishers
+- **Budget efficiency** — fraction of budget left unused
+- **False positive penalty** — −0.2 per clean publisher incorrectly flagged
+
+Clamped to [0, 1].
 
 ## Deployment
 

inference.py

@@ -64,13 +64,13 @@ MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-7B-Instruct")
 
 _VALID_TASKS = {"easy", "medium", "hard"}
 _task_env = os.getenv("ADAUDIT_TASK", "").strip().lower()
-TASK_NAME = _task_env if _task_env in _VALID_TASKS else "hard"
+TASK_NAME = _task_env if _task_env in _VALID_TASKS else "medium"
 BENCHMARK = os.getenv("ADAUDIT_BENCHMARK", "adaudit")
 TEMPERATURE = 0.0
 MAX_TOKENS = 2048
 HISTORY_WINDOW = 5
 BASELINE_DAYS = 3
-SUCCESS_SCORE_THRESHOLD = 0.5
+SUCCESS_SCORE_THRESHOLD = 0.4
 
 # Rule-based investigation tools per fraud type
 TOOLS_FOR = {
@@ -126,7 +126,7 @@ def log_step(step: int, action: str, reward: float, done: bool, error: Optional[
 
 def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
     rewards_str = ",".join(f"{r:.2f}" for r in rewards)
-    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.2f} rewards={rewards_str}", flush=True)
 
 
 # ---------------------------------------------------------------------------
@@ -326,15 +326,7 @@ def get_rule_action(
 # Main
 # ---------------------------------------------------------------------------
 
-def main() -> None:
-    # Try to init LLM client; fall back to rule-based if it fails
-    llm_client: Optional[OpenAI] = None
-    try:
-        llm_client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-        llm_client.models.list()
-    except Exception:
-        llm_client = None
-
+def run_episode(task_name: str, llm_client: Optional[OpenAI]) -> None:
     use_rules = llm_client is None
 
     env = AdAuditEnv()
@@ -353,10 +345,10 @@ def main() -> None:
     investigated: Dict[str, List[str]] = {}
     flagged: set = set()
 
-    log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME if not use_rules else "rule-based")
+    log_start(task=task_name, env=BENCHMARK, model=MODEL_NAME if not use_rules else "rule-based")
 
     try:
-        obs = env.reset(episode_id=TASK_NAME)
+        obs = env.reset(episode_id=task_name)
         obs_dict = obs.model_dump()
 
         while not obs_dict.get("done", False) and steps_taken < EPISODE_DAYS:
@@ -421,5 +413,18 @@ def main() -> None:
         log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
 
 
+def main() -> None:
+    # Try to init LLM client; fall back to rule-based if it fails
+    llm_client: Optional[OpenAI] = None
+    try:
+        llm_client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+        llm_client.models.list()
+    except Exception:
+        llm_client = None
+
+    for task in sorted(_VALID_TASKS):
+        run_episode(task, llm_client)
+
+
 if __name__ == "__main__":
     main()