"""CPU-only contracts for the certified intervention evaluation. The release already contains executor-certified gold. Evaluation therefore does not need an annotation workflow: it flattens the frozen group rows, joins one prediction per view, and computes the registered group-aware metrics. """ from __future__ import annotations import copy import json from collections import Counter, defaultdict from collections.abc import Iterable, Mapping, Sequence from pathlib import Path from typing import Any from ..atomic_io import atomic_write_json, atomic_write_jsonl, read_jsonl from ..hashing import canonical_json_hash from ..training.answers import ( UNANSWERABLE_TOKEN, NormalizationError, answers_equal, normalize_answer, parse_answer, ) from ..training.targets import ANSWERABLE_STATES, UNANSWERABLE_STATES, ours_target class EvaluationError(ValueError): """Raised when frozen gold, predictions, or a score join is incomplete.""" _REQUIRED_GROUP_FIELDS = ( "group_id", "base_id", "source", "split", "question", "choices", "full_answer_canonical", "answer_type", "views", ) def _object(value: Any, label: str) -> Mapping[str, Any]: if not isinstance(value, Mapping): raise EvaluationError(f"{label} must be an object") return value def _nonempty_string(value: Any, label: str) -> str: if not isinstance(value, str) or not value: raise EvaluationError(f"{label} must be a non-empty string") return value def _safe_images( value: Any, *, eval_id: str, allow_empty: bool = False, ) -> list[dict[str, Any]]: if not isinstance(value, list) or (not value and not allow_empty): raise EvaluationError(f"{eval_id}: evaluation view has no image") images: list[dict[str, Any]] = [] for index, raw in enumerate(value): image = dict(_object(raw, f"{eval_id} image")) path = _nonempty_string(image.get("path"), f"{eval_id} image path") relative = Path(path) if relative.is_absolute() or ".." in relative.parts or "\\" in path: raise EvaluationError(f"{eval_id}: unsafe image path {path!r}") if image.get("image_index") != index: raise EvaluationError(f"{eval_id}: image indices must be contiguous") images.append(image) return images def _slice_values(group: Mapping[str, Any], view: Mapping[str, Any]) -> dict[str, str]: values = { "source": str(group.get("source", "unknown")), "split": str(group.get("split", "unknown")), "state": str(view.get("state", "unknown")), "intervention_operator": str(view.get("operator", "unknown")), "source_role": str(view.get("role", "unknown")), "answer_type": str(group.get("answer_type", "unknown")), "certificate_tier": str(view.get("certification_tier", "unknown")), "subject": str(group.get("subject") or "unknown"), "dependency_depth": str( group.get("dependency_depth") if group.get("dependency_depth") is not None else "unknown" ), "renderer_family": str( view.get("renderer_family") or view.get("renderer") or group.get("renderer_family") or "unknown" ), } values["intervention_family"] = ( "original" if values["state"] == "FULL" else ("substitution" if values["source_role"] == "SUBSTITUTE" else "removal_or_control") ) return values def flatten_certified_groups(groups: Iterable[Mapping[str, Any]]) -> tuple[dict[str, Any], ...]: """Flatten certified group rows into one immutable evaluation row per view.""" rows: list[dict[str, Any]] = [] seen_groups: set[str] = set() seen_base_ids: set[str] = set() seen_eval_ids: set[str] = set() for group_index, raw_group in enumerate(groups): group = dict(_object(raw_group, f"group[{group_index}]")) missing = [field for field in _REQUIRED_GROUP_FIELDS if field not in group] if missing: raise EvaluationError(f"group[{group_index}] missing fields: {missing}") group_id = _nonempty_string(group["group_id"], "group_id") base_id = _nonempty_string(group["base_id"], "base_id") if group_id in seen_groups or base_id in seen_base_ids: raise EvaluationError(f"duplicate evaluation group/base identity: {group_id}/{base_id}") seen_groups.add(group_id) seen_base_ids.add(base_id) question = _nonempty_string(group["question"], f"{group_id} question") choices = group["choices"] if not isinstance(choices, list) or any(not isinstance(item, Mapping) for item in choices): raise EvaluationError(f"{group_id}: choices must be a list of objects") answer_type = _nonempty_string(group["answer_type"], f"{group_id} answer_type") views = group["views"] if not isinstance(views, list) or not views: raise EvaluationError(f"{group_id}: views must be a non-empty list") states = Counter(str(_object(view, "view").get("state", "")) for view in views) if states["FULL"] != 1: raise EvaluationError(f"{group_id}: exactly one FULL view is required") for raw_view in views: view = dict(_object(raw_view, f"{group_id} view")) view_id = _nonempty_string(view.get("view_id"), f"{group_id} view_id") state = _nonempty_string(view.get("state"), f"{view_id} state") if state not in ANSWERABLE_STATES | UNANSWERABLE_STATES: raise EvaluationError(f"{view_id}: unsupported state {state!r}") eval_id = canonical_json_hash({"group_id": group_id, "view_id": view_id}) if eval_id in seen_eval_ids: raise EvaluationError(f"duplicate evaluation view: {view_id}") seen_eval_ids.add(eval_id) try: gold = ours_target(view, group["full_answer_canonical"]) normalize_answer(gold, answer_type, choices=choices) except (ValueError, NormalizationError) as exc: raise EvaluationError(f"{view_id}: invalid certified target: {exc}") from exc rows.append( { "schema_version": 1, "eval_id": eval_id, "benchmark": ( "certified_intervention_primary" if group["split"] == "certified_eval" else "certified_intervention_secondary" ), "group_id": group_id, "base_id": base_id, "source": str(group["source"]), "split": str(group["split"]), "view_id": view_id, "state": state, "role": str(view.get("role", "")), "operator": str(view.get("operator", "")), "question": question, "choices": [copy.deepcopy(dict(choice)) for choice in choices], "images": _safe_images(view.get("images"), eval_id=eval_id), "gold_target": str(gold), "answer_type": answer_type, "slices": _slice_values(group, view), } ) if not rows: raise EvaluationError("evaluation group input is empty") rows.sort(key=lambda row: (str(row["group_id"]), str(row["view_id"]))) return tuple(rows) def freeze_certified_groups( group_paths: Sequence[Path], output_path: Path, *, expected_groups: int | None = None, ) -> dict[str, Any]: """Flatten one or more release split files and write a write-once manifest.""" if not group_paths: raise EvaluationError("at least one --groups file is required") groups: list[Mapping[str, Any]] = [] try: for path in group_paths: groups.extend(_object(row, f"row in {path}") for row in read_jsonl(path)) except (OSError, json.JSONDecodeError) as exc: raise EvaluationError(f"cannot read evaluation groups: {exc}") from exc rows = flatten_certified_groups(groups) group_count = len({str(row["group_id"]) for row in rows}) if expected_groups is not None and group_count != expected_groups: raise EvaluationError( f"evaluation group count {group_count} differs from expected {expected_groups}" ) if output_path.exists(): existing = tuple(read_jsonl(output_path)) if existing != rows: raise EvaluationError( f"refusing to overwrite drifted evaluation manifest: {output_path}" ) else: atomic_write_jsonl(output_path, rows) return { "schema_version": 1, "kind": "certified_intervention_evaluation_manifest", "path": str(output_path.resolve()), "group_count": group_count, "view_count": len(rows), "source_counts": dict(sorted(Counter(str(row["source"]) for row in rows).items())), "split_counts": dict(sorted(Counter(str(row["split"]) for row in rows).items())), "state_counts": dict(sorted(Counter(str(row["state"]) for row in rows).items())), } def flatten_retention_items(items: Iterable[Mapping[str, Any]]) -> tuple[dict[str, Any], ...]: """Convert untouched normalized eval items to the common prediction schema.""" rows: list[dict[str, Any]] = [] seen: set[str] = set() for index, raw_item in enumerate(items): item = dict(_object(raw_item, f"retention item[{index}]")) base_id = _nonempty_string(item.get("base_id"), f"retention item[{index}] base_id") if base_id in seen: raise EvaluationError(f"duplicate retention base_id: {base_id}") seen.add(base_id) question = _nonempty_string(item.get("question"), f"{base_id} question") source = _nonempty_string(item.get("source"), f"{base_id} source") split = _nonempty_string(item.get("source_split"), f"{base_id} source_split") source_revision = str(item.get("source_revision") or "unknown") source_config = str(item.get("source_config") or "default") choices = item.get("choices") image_paths = item.get("image_paths") answer_type = _nonempty_string(item.get("answer_type"), f"{base_id} answer_type") if not isinstance(choices, list) or any( not isinstance(choice, Mapping) for choice in choices ): raise EvaluationError(f"{base_id}: retention choices are malformed") if not isinstance(image_paths, list) or any( not isinstance(path, str) for path in image_paths ): raise EvaluationError(f"{base_id}: retention image paths are malformed") gold = item.get("answer_canonical") if not isinstance(gold, str | int | float | bool): raise EvaluationError(f"{base_id}: retention gold answer is missing") try: normalized_gold = normalize_answer(str(gold), answer_type, choices=choices) except NormalizationError as exc: raise EvaluationError(f"{base_id}: invalid retention gold: {exc}") from exc eval_id = canonical_json_hash({"benchmark": "untouched_retention", "base_id": base_id}) images = [ {"image_index": image_index, "path": path} for image_index, path in enumerate(image_paths) ] rows.append( { "schema_version": 1, "eval_id": eval_id, "benchmark": "untouched_retention", "group_id": base_id, "base_id": base_id, "source": source, "source_revision": source_revision, "source_config": source_config, "split": split, "view_id": base_id, "state": "ORIGINAL", "role": "ORIGINAL", "operator": "identity", "question": question, "choices": [copy.deepcopy(dict(choice)) for choice in choices], "images": _safe_images(images, eval_id=eval_id, allow_empty=True), "gold_target": normalized_gold, "answer_type": answer_type, "slices": { "source": source, "source_revision": source_revision, "source_config": source_config, "split": split, "state": "ORIGINAL", "answer_type": answer_type, "subject": str(item.get("subject") or "unknown"), }, } ) if not rows: raise EvaluationError("retention item input is empty") rows.sort(key=lambda row: (str(row["source"]), str(row["base_id"]))) return tuple(rows) def freeze_retention_items( item_paths: Sequence[Path], output_path: Path, *, expected_items: int | None = None, ) -> dict[str, Any]: """Write a common, write-once manifest for untouched capability probes.""" if not item_paths: raise EvaluationError("at least one --items file is required") items: list[Mapping[str, Any]] = [] try: for path in item_paths: items.extend(_object(row, f"row in {path}") for row in read_jsonl(path)) except (OSError, json.JSONDecodeError) as exc: raise EvaluationError(f"cannot read retention items: {exc}") from exc rows = flatten_retention_items(items) if expected_items is not None and len(rows) != expected_items: raise EvaluationError( f"retention item count {len(rows)} differs from expected {expected_items}" ) if output_path.exists(): existing = tuple(read_jsonl(output_path)) if existing != rows: raise EvaluationError( f"refusing to overwrite drifted retention manifest: {output_path}" ) else: atomic_write_jsonl(output_path, rows) return { "schema_version": 1, "kind": "untouched_retention_evaluation_manifest", "path": str(output_path.resolve()), "item_count": len(rows), "source_counts": dict(sorted(Counter(str(row["source"]) for row in rows).items())), } def load_evaluation_manifest(path: Path) -> tuple[dict[str, Any], ...]: try: rows = tuple(dict(_object(row, f"row in {path}")) for row in read_jsonl(path)) except (OSError, json.JSONDecodeError) as exc: raise EvaluationError(f"cannot read evaluation manifest: {exc}") from exc if not rows: raise EvaluationError("evaluation manifest is empty") ids = [row.get("eval_id") for row in rows] if any(not isinstance(value, str) or not value for value in ids) or len(ids) != len(set(ids)): raise EvaluationError("evaluation manifest has empty or duplicate eval_id values") return rows def _rate(numerator: int, denominator: int) -> dict[str, int | float | None]: return { "numerator": numerator, "denominator": denominator, "value": (numerator / denominator if denominator else None), } def _accuracy(rows: Sequence[Mapping[str, Any]]) -> dict[str, int | float | None]: return _rate(sum(bool(row["correct"]) for row in rows), len(rows)) def _slice_metrics(scored: Sequence[Mapping[str, Any]]) -> dict[str, dict[str, Any]]: buckets: dict[str, dict[str, list[Mapping[str, Any]]]] = defaultdict(lambda: defaultdict(list)) for row in scored: raw_slices = row.get("slices") if not isinstance(raw_slices, Mapping): continue for name, value in raw_slices.items(): buckets[str(name)][str(value)].append(row) return { name: {value: _accuracy(bucket) for value, bucket in sorted(values.items())} for name, values in sorted(buckets.items()) } def _aggregate_score_metrics(scored: Sequence[Mapping[str, Any]]) -> dict[str, Any]: by_state: dict[str, list[Mapping[str, Any]]] = defaultdict(list) by_group: dict[str, list[Mapping[str, Any]]] = defaultdict(list) for row in scored: by_state[str(row["state"])].append(row) by_group[str(row["group_id"])].append(row) full_correct_groups = { group_id for group_id, rows in by_group.items() if len(full := [row for row in rows if row["state"] == "FULL"]) == 1 and bool(full[0]["correct"]) } transformed = [row for row in scored if row["state"] not in {"FULL", "ORIGINAL"}] transformed_conditioned = [row for row in transformed if row["group_id"] in full_correct_groups] unanswerable = [row for row in scored if bool(row["gold_unanswerable"])] answerable = [row for row in scored if not bool(row["gold_unanswerable"])] strict_correct = sum(all(bool(row["correct"]) for row in rows) for rows in by_group.values()) result: dict[str, Any] = { "group_count": len(by_group), "view_count": len(scored), "accuracy": _accuracy(scored), "strict_group_accuracy": _rate(strict_correct, len(by_group)), "unsupported_answer_rate": _rate( sum(bool(row["unsupported_answer"]) for row in unanswerable), len(unanswerable) ), "false_abstention_rate": _rate( sum(bool(row["false_abstention"]) for row in answerable), len(answerable) ), "transformed_accuracy": _accuracy(transformed), "transformed_accuracy_conditioned_on_full_correct": _accuracy(transformed_conditioned), "full_correct_group_count": len(full_correct_groups), "slices": _slice_metrics(scored), } for state, name in { "FULL": "full_accuracy", "A_SAME": "a_same_accuracy", "A_CHANGED": "a_changed_accuracy", "U_MISSING": "u_missing_abstention_accuracy", "U_INVALID": "u_invalid_abstention_accuracy", "ORIGINAL": "retention_accuracy", }.items(): result[name] = _accuracy(by_state.get(state, [])) return result def score_predictions( gold_rows: Sequence[Mapping[str, Any]], prediction_rows: Sequence[Mapping[str, Any]], ) -> tuple[dict[str, Any], tuple[dict[str, Any], ...]]: """Join exact prediction coverage and compute the registered primary metrics.""" if not gold_rows: raise EvaluationError("gold evaluation rows are empty") predictions: dict[str, Mapping[str, Any]] = {} run_ids: set[str] = set() for index, raw in enumerate(prediction_rows): row = _object(raw, f"prediction[{index}]") eval_id = _nonempty_string(row.get("eval_id"), f"prediction[{index}] eval_id") if eval_id in predictions: raise EvaluationError(f"duplicate prediction eval_id: {eval_id}") predictions[eval_id] = row run_ids.add(_nonempty_string(row.get("run_id"), f"prediction[{index}] run_id")) if len(run_ids) != 1: raise EvaluationError("prediction file must contain exactly one run_id") gold_ids = {_nonempty_string(row.get("eval_id"), "gold eval_id") for row in gold_rows} missing = sorted(gold_ids - predictions.keys()) extra = sorted(predictions.keys() - gold_ids) if missing or extra: raise EvaluationError( f"prediction coverage mismatch: missing={missing[:5]}, extra={extra[:5]}" ) scored: list[dict[str, Any]] = [] for raw_gold in gold_rows: gold = _object(raw_gold, "gold row") eval_id = str(gold["eval_id"]) prediction = predictions[eval_id] if prediction.get("prompt_truncated") is True: raise EvaluationError(f"{eval_id}: prompt truncation is an integrity failure") if prediction.get("completion_truncated") is True: raise EvaluationError(f"{eval_id}: completion truncation is an integrity failure") response = prediction.get("response") if not isinstance(response, str): raise EvaluationError(f"{eval_id}: prediction response must be a string") parsed = parse_answer(response) normalized_prediction: str | None = None if parsed.valid: try: normalized_prediction = normalize_answer( parsed.require_content(), str(gold["answer_type"]), choices=gold.get("choices") if isinstance(gold.get("choices"), list) else [], ) except NormalizationError: normalized_prediction = None correct = parsed.valid and answers_equal( parsed.require_content(), gold["gold_target"], str(gold["answer_type"]), choices=gold.get("choices") if isinstance(gold.get("choices"), list) else [], ) gold_unanswerable = str(gold["gold_target"]) == UNANSWERABLE_TOKEN predicted_unanswerable = normalized_prediction == UNANSWERABLE_TOKEN scored.append( { "schema_version": 1, "run_id": next(iter(run_ids)), "eval_id": eval_id, "group_id": str(gold["group_id"]), "base_id": str(gold["base_id"]), "benchmark": str(gold.get("benchmark", "certified_intervention_primary")), "source": str(gold["source"]), "split": str(gold["split"]), "state": str(gold["state"]), "gold_target": str(gold["gold_target"]), "response": response, "parser_valid": parsed.valid, "parser_error": parsed.error, "normalized_prediction": normalized_prediction, "correct": bool(correct), "gold_unanswerable": gold_unanswerable, "predicted_unanswerable": predicted_unanswerable, "unsupported_answer": bool( gold_unanswerable and parsed.valid and not predicted_unanswerable ), "false_abstention": bool( not gold_unanswerable and parsed.valid and predicted_unanswerable ), "slices": copy.deepcopy(dict(_object(gold.get("slices", {}), "slices"))), } ) by_benchmark: dict[str, list[Mapping[str, Any]]] = defaultdict(list) for row in scored: by_benchmark[str(row["benchmark"])].append(row) benchmark_metrics = { benchmark: _aggregate_score_metrics(rows) for benchmark, rows in sorted(by_benchmark.items()) } selected_benchmark = ( "certified_intervention_primary" if "certified_intervention_primary" in benchmark_metrics else next(iter(benchmark_metrics)) ) metrics: dict[str, Any] = { "schema_version": 1, "kind": "evaluation_score", "run_id": next(iter(run_ids)), "selected_benchmark": selected_benchmark, "benchmark_metrics": benchmark_metrics, **benchmark_metrics[selected_benchmark], } return metrics, tuple(scored) def write_score_outputs( output_dir: Path, metrics: Mapping[str, Any], scored_rows: Sequence[Mapping[str, Any]], ) -> None: if output_dir.exists() and any(output_dir.iterdir()): raise EvaluationError(f"score output directory is not empty: {output_dir}") output_dir.mkdir(parents=True, exist_ok=True) atomic_write_json(output_dir / "metrics.json", dict(metrics)) atomic_write_jsonl(output_dir / "scored.jsonl", scored_rows)