| """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) |
|
|
