scripts_depmap/run_ge_l3_judge.py

#!/usr/bin/env python3
"""Run LLM-as-Judge evaluation for GE-L3 reasoning predictions.

Reads GE-L3 predictions, sends through judge model, computes scores.

Usage:
  python scripts_depmap/run_ge_l3_judge.py --judge-provider gemini --judge-model gemini-2.5-flash
  python scripts_depmap/run_ge_l3_judge.py --run-dir results/ge_llm/ge-l3_qwen2-5-7b-instruct_3-shot_fs0

Output per run:
  results/ge_llm/{run}_judged/
      judge_scores.jsonl, results.json, judge_meta.json
"""

import argparse
import json
import time
from datetime import datetime, timezone
from pathlib import Path

from negbiodb.llm_client import LLMClient
from negbiodb_depmap.llm_eval import GE_L3_JUDGE_PROMPT, evaluate_ge_l3, parse_ge_l3_judge_scores

PROJECT_ROOT = Path(__file__).resolve().parent.parent
RESULTS_DIR = PROJECT_ROOT / "results" / "ge_llm"
DATA_DIR = PROJECT_ROOT / "exports" / "ge_llm"
L3_DATASET_FILE = DATA_DIR / "ge_l3_dataset.jsonl"


def load_gold_records() -> list[dict]:
    """Load GE-L3 gold records."""
    records = []
    with open(L3_DATASET_FILE) as f:
        for line in f:
            records.append(json.loads(line))
    return records


def load_predictions(pred_path: Path) -> list[dict]:
    """Load predictions from JSONL."""
    preds = []
    with open(pred_path) as f:
        for line in f:
            preds.append(json.loads(line))
    return preds


def find_l3_runs(results_dir: Path) -> list[Path]:
    """Find all GE-L3 run directories."""
    runs = []
    for d in sorted(results_dir.iterdir()):
        if d.is_dir() and d.name.startswith("ge-l3_"):
            pred_file = d / "predictions.jsonl"
            if pred_file.exists():
                runs.append(d)
    return runs


def judge_run(
    run_dir: Path,
    gold_records: list[dict],
    client: LLMClient,
    judge_model: str,
) -> dict:
    """Judge all predictions in a run directory."""
    gold_by_id = {rec["question_id"]: rec for rec in gold_records}

    predictions = load_predictions(run_dir / "predictions.jsonl")

    judged_dir = run_dir.parent / f"{run_dir.name}_judged"
    judged_dir.mkdir(parents=True, exist_ok=True)

    # Resume support
    scores_path = judged_dir / "judge_scores.jsonl"
    completed = {}
    if scores_path.exists():
        with open(scores_path) as f:
            for line in f:
                rec = json.loads(line)
                if rec.get("scores") is not None:
                    completed[rec["question_id"]] = rec
        print(f"  Resume: {len(completed)} already judged")

    remaining = [p for p in predictions if p["question_id"] not in completed]
    print(f"  Judging {len(remaining)} remaining of {len(predictions)} total")

    start_time = time.time()
    with open(scores_path, "a") as f:
        for i, pred_rec in enumerate(remaining):
            qid = pred_rec["question_id"]
            gold = gold_by_id.get(qid)
            if gold is None:
                print(f"  Warning: no gold record for {qid}, skipping")
                continue

            prompt = GE_L3_JUDGE_PROMPT.format(
                context_text=gold.get("context_text", ""),
                response_text=pred_rec["prediction"],
            )

            try:
                judge_response = client.generate(prompt)
            except Exception as e:
                print(f"  Error judging {qid}: {e}")
                judge_response = f"ERROR: {e}"

            scores = parse_ge_l3_judge_scores(judge_response)

            score_rec = {
                "question_id": qid,
                "judge_response": judge_response,
                "scores": scores,
            }
            f.write(json.dumps(score_rec, ensure_ascii=False) + "\n")
            f.flush()
            completed[qid] = score_rec

            if (i + 1) % 10 == 0:
                elapsed = time.time() - start_time
                rate = (i + 1) / elapsed * 60
                print(f"  Progress: {i + 1}/{len(remaining)} ({rate:.1f}/min)")

    elapsed = time.time() - start_time
    print(f"  Judging complete: {elapsed:.0f}s")

    # Aggregate — evaluate_ge_l3 expects raw judge response strings
    all_outputs = []
    for pred_rec in predictions:
        qid = pred_rec["question_id"]
        if qid in completed and completed[qid].get("judge_response"):
            all_outputs.append(completed[qid]["judge_response"])
        else:
            all_outputs.append("")

    metrics = evaluate_ge_l3(all_outputs)

    with open(judged_dir / "results.json", "w") as f:
        json.dump(metrics, f, indent=2)

    meta = {
        "judge_model": judge_model,
        "source_run": run_dir.name,
        "n_predictions": len(predictions),
        "n_judged": sum(1 for o in all_outputs if o),
        "elapsed_seconds": elapsed,
        "timestamp": datetime.now(timezone.utc).isoformat(),
    }
    with open(judged_dir / "judge_meta.json", "w") as f:
        json.dump(meta, f, indent=2)

    return metrics


def main():
    parser = argparse.ArgumentParser(description="Run GE-L3 LLM-as-Judge evaluation")
    parser.add_argument("--run-dir", type=Path, default=None)
    parser.add_argument("--results-dir", type=Path, default=RESULTS_DIR)
    parser.add_argument("--judge-provider", default="gemini", choices=["gemini", "openai", "vllm"])
    parser.add_argument("--judge-model", default="gemini-2.5-flash")
    parser.add_argument("--api-base", default=None)
    parser.add_argument("--api-key", default=None)
    parser.add_argument("--temperature", type=float, default=0.0)
    parser.add_argument("--max-tokens", type=int, default=512)
    args = parser.parse_args()

    print("Loading GE-L3 gold records...")
    gold_records = load_gold_records()
    test_records = [r for r in gold_records if r.get("split") == "test"]
    print(f"  Total: {len(gold_records)}, Test: {len(test_records)}")

    print(f"\nInitializing judge: {args.judge_model} ({args.judge_provider})")
    client = LLMClient(
        provider=args.judge_provider,
        model=args.judge_model,
        api_base=args.api_base,
        api_key=args.api_key,
        temperature=args.temperature,
        max_tokens=args.max_tokens,
    )

    if args.run_dir:
        runs = [args.run_dir]
    else:
        runs = find_l3_runs(args.results_dir)
    print(f"  Found {len(runs)} GE-L3 runs to judge")

    for run_dir in runs:
        print(f"\n=== Judging: {run_dir.name} ===")
        metrics = judge_run(run_dir, gold_records, client, args.judge_model)

        for dim in ["biological_plausibility", "pathway_reasoning",
                     "context_specificity", "mechanistic_depth"]:
            key_mean = f"{dim}_mean"
            key_std = f"{dim}_std"
            if key_mean in metrics:
                print(f"  {dim}: {metrics[key_mean]:.2f} +/- {metrics[key_std]:.2f}")
        print(f"  Overall: {metrics.get('overall_mean', 0):.2f} +/- {metrics.get('overall_std', 0):.2f}")
        print(f"  Parsed: {metrics.get('n_parsed', 0)}/{metrics.get('n_total', 0)}")

    print(f"\n=== All {len(runs)} runs judged ===")


if __name__ == "__main__":
    main()