lsvbench/tasks/monitoring_step.py

"""Monitoring step-identification task."""

from __future__ import annotations

from collections import Counter
from pathlib import Path
from typing import Any

from ..io import BENCHMARK_ROOT, DATA_DIR, manifest_examples, select_shard
from ..metrics import bootstrap_sem, classification_scores
from ..parsing import normalize_step_id, parse_monitoring_response
from .base import BenchmarkTask, TaskSpec


class MonitoringStepTask(BenchmarkTask):
    spec = TaskSpec(
        name="monitoring_step",
        display_name="Protocol Monitoring Step Prediction",
        default_manifest=DATA_DIR / "monitoring_step_eval.json",
    )
    primary_metric = "step_balanced_accuracy"

    def load_examples(
        self,
        *,
        benchmark_root: Path = BENCHMARK_ROOT,
        manifest_path: Path | None = None,
        video_root: Path | None = None,
        num_shards: int = 1,
        shard_index: int = 0,
        limit: int | None = None,
    ) -> list[dict[str, Any]]:
        rows = manifest_examples(manifest_path or self.default_manifest)
        root = video_root or benchmark_root
        for row in rows:
            row["task"] = self.name
            row["_video_abs"] = str(root / str(row["video_path"]))
        rows = sorted(rows, key=lambda row: str(row.get("eval_id")))
        if limit is not None:
            rows = rows[:limit]
        return select_shard(rows, num_shards, shard_index)

    def parse_record(self, row: dict[str, Any]) -> dict[str, Any]:
        if row.get("error"):
            return row
        raw = str(row.get("raw_response") or "")
        pred_candidate, pred_step = parse_monitoring_response(raw) if raw else (None, None)
        pred_step_normalized = normalize_step_id(pred_step)
        target_step_normalized = normalize_step_id(row.get("target_step_id"))
        row.update(
            {
                "pred_candidate_matches": pred_candidate,
                "pred_observed_step_id": pred_step,
                "pred_observed_step_id_normalized": pred_step_normalized,
                "target_step_id_normalized": target_step_normalized,
                "pred_parse_ok": pred_step_normalized is not None,
                "candidate_correct": (
                    pred_candidate is not None
                    and bool(pred_candidate) == bool(row.get("target_candidate_matches"))
                )
                if row.get("target_candidate_matches") is not None
                else None,
                "observed_step_correct": pred_step_normalized is not None
                and pred_step_normalized == target_step_normalized,
            }
        )
        return row

    def _summary(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
        parsed = self.parse_rows(rows)
        scored = [row for row in parsed if not row.get("error")]
        step_rows = [row for row in scored if str(row.get("task_type") or "step_identification") == "step_identification"]
        pairs = [
            (normalize_step_id(row.get("target_step_id")), normalize_step_id(row.get("pred_observed_step_id")))
            for row in step_rows
            if normalize_step_id(row.get("target_step_id")) is not None
        ]
        labels = sorted({str(target) for target, _ in pairs})
        scores = classification_scores(pairs, labels=labels)
        candidate_rows = [row for row in scored if row.get("target_candidate_matches") is not None]
        candidate_correct = sum(1 for row in candidate_rows if row.get("candidate_correct"))
        parse_errors = sum(1 for row in scored if not row.get("pred_parse_ok"))
        return {
            "task": self.name,
            "display_name": self.display_name,
            "rows": len(rows),
            "scored": len(scored),
            "errors": sum(1 for row in rows if row.get("error")),
            "parse_errors": parse_errors,
            "parse_success_rate": (len(scored) - parse_errors) / len(scored) if scored else None,
            "candidate_match_rows": len(candidate_rows),
            "candidate_match_accuracy": candidate_correct / len(candidate_rows) if candidate_rows else None,
            "step_identification_rows": len(step_rows),
            "step_identification_accuracy": scores["accuracy"],
            "observed_step_id_accuracy": scores["accuracy"],
            "step_parse_success_rate": (len(step_rows) - parse_errors) / len(step_rows) if step_rows else None,
            "step_balanced_accuracy": scores["balanced_accuracy"],
            "step_macro_f1": scores["macro_f1"],
            "step_macro_precision": scores["macro_precision"],
            "step_macro_recall": scores["macro_recall"],
            "step_precision_by_id": scores["precision"],
            "step_recall_by_id": scores["recall"],
            "step_f1_by_id": scores["f1"],
            "step_confusion": scores["confusion"],
            "task_counts": dict(Counter(str(row.get("task_type")) for row in scored)),
            "target_counts": scores["target_counts"],
            "pred_counts": scores["pred_counts"],
        }

    def score(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
        parsed = self.parse_rows(rows)
        summary = self._summary(parsed)
        for metric in (
            "step_identification_accuracy",
            "step_balanced_accuracy",
            "step_macro_f1",
            "step_macro_precision",
            "step_macro_recall",
        ):
            summary[f"{metric}_sem"] = bootstrap_sem(parsed, metric, self._summary, iterations=200)
        return summary