penfever's picture
Release native-format structure-closure validation cohort
44353e7 verified
Raw History Blame Contribute Delete
9.29 kB
# Copyright The Marin Authors
# SPDX-License-Identifier: Apache-2.0
"""Bind closure evaluation dumps to an immutable, ordered validation cohort."""
import argparse
import hashlib
import json
from collections import Counter
from collections.abc import Iterable, Sequence
from dataclasses import asdict, dataclass
from enum import StrEnum
from pathlib import Path
from rolloutengine.closure_scoring import (
CLOSURE_REGION_SCORER,
ClosureFormat,
ContinuationOutcome,
closure_response_content,
continuation_outcome,
score_closure_region,
)
from rolloutengine.tool_protocol import ToolCallStatus, tool_call_regions
from experiments.post_training.structure_closure.token_data import TokenizedCaseRecord
class UidSource(StrEnum):
ROW_INDEX = "row_index"
CASE_ID = "case_id"
def cases_by_uid(cases: Sequence[TokenizedCaseRecord], source: UidSource) -> dict[str, TokenizedCaseRecord]:
"""Index the cohort using the ID convention recorded by its evaluation path."""
identities = [
str(index) if source == UidSource.ROW_INDEX else "structure-closure:" + case["case_id"]
for index, case in enumerate(cases)
]
if len(set(identities)) != len(cases):
raise ValueError("Validation cohort contains duplicate evaluation identities")
return dict(zip(identities, cases, strict=True))
@dataclass(frozen=True)
class CaseResult:
uid: str
case_id: str
family: str
control: str
syntax_complete: bool
content_preserved: bool
success: bool
trailing_content: bool
whole_response_success: bool
control_outcome: ContinuationOutcome | None
tool_protocol_status: ToolCallStatus | None
@dataclass(frozen=True)
class AuditFailure:
uid: str
reason: str
@dataclass(frozen=True)
class EvaluationAudit:
expected: int
observed: int
missing_uids: tuple[str, ...]
failures: tuple[AuditFailure, ...]
results: tuple[CaseResult, ...]
@property
def complete(self) -> bool:
return self.expected > 0 and not self.missing_uids and not self.failures and len(self.results) == self.expected
def summary(self) -> dict:
groups: dict[str, Counter] = {}
control_outcomes: dict[str, Counter] = {}
tool_protocol: dict[str, Counter] = {}
for result in self.results:
if result.control_outcome is not None:
control_outcomes.setdefault(f"{result.family}/{result.control}", Counter())[result.control_outcome] += 1
if result.tool_protocol_status is not None:
tool_protocol.setdefault(f"{result.family}/{result.control}", Counter())[
result.tool_protocol_status
] += 1
for key in (result.family, f"{result.family}/{result.control}"):
counts = groups.setdefault(key, Counter())
counts.update(
scored=1,
syntax_complete=int(result.syntax_complete),
content_preserved=int(result.content_preserved),
success=int(result.success),
failure=int(not result.success),
trailing_content=int(result.trailing_content),
whole_response_success=int(result.whole_response_success),
)
return {
"scorer": CLOSURE_REGION_SCORER,
"complete": self.complete,
**asdict(self),
"groups": dict(sorted(groups.items())),
"control_outcomes": dict(sorted(control_outcomes.items())),
"tool_protocol": dict(sorted(tool_protocol.items())),
}
def audit_evaluation(
cases: Sequence[TokenizedCaseRecord], rows: Iterable[dict], *, uid_source: UidSource
) -> EvaluationAudit:
"""Check one sample per case, exact conditioning, and agreement with local scoring.
Select row indices for batch evaluation or stable case IDs for step-wise
evaluation. Row indices require the exact unfiltered validation cohort with
closure rows first, as in the launch recipe.
All row failures are retained; an incomplete audit cannot establish improvement.
"""
expected = cases_by_uid(cases, uid_source)
seen: set[str] = set()
results = []
failures = []
observed = 0
for row in rows:
observed += 1
uid = str(row.get("uid", ""))
try:
if uid not in expected or uid in seen:
raise ValueError("Unknown or duplicate evaluation UID")
seen.add(uid)
case = expected[uid]
if row["prompt_token_ids"] != case["prompt_token_ids"]:
raise ValueError("Evaluation conditioning differs from the frozen case")
if row["env_class"] != "structure_closure" or row["data_source"] != "structure-closure":
raise ValueError("Evaluation task/session identity differs from the closure cohort")
if row.get("exception_type") or row.get("server_error"):
raise ValueError("Infrastructure error: case cannot be counted as scored")
verification = row.get("verification")
if verification is None or verification["status"] != "verified":
raise ValueError("Verifier score is unavailable")
content = closure_response_content(row["output_response"], stop_reason=row["stop_reason"])
score = score_closure_region(case["prefix"] + content, case["expected"], ClosureFormat(case["format"]))
metric = f"{CLOSURE_REGION_SCORER}/{case['family']}/{case['control']}"
for name, value in asdict(score).items():
if row["env_metrics"][f"{metric}/{name}"] != float(value):
raise ValueError(f"Saved {name} metric disagrees with rescored response")
if verification["score"] != float(score.success) or sum(row["score"]) != float(score.success):
raise ValueError("Reward/verifier score disagrees with rescored response")
control_outcome = None
tool_protocol_status = None
if case["format"] == ClosureFormat.TOOL:
regions = tool_call_regions(case["prefix"] + content, initial_thinking=False)
if not regions or regions[0].start != 0:
raise ValueError("Tool cohort does not start with an outside-thinking tool call")
tool_protocol_status = regions[0].status
if case["control"] in ("continue_required", "escape_continue_required", "value_continue_required"):
control_outcome = continuation_outcome(
case["prefix"] + content, case["expected"], ClosureFormat(case["format"])
)
results.append(
CaseResult(
uid,
case["case_id"],
case["family"],
case["control"],
**asdict(score),
control_outcome=control_outcome,
tool_protocol_status=tool_protocol_status,
)
)
except (KeyError, TypeError, ValueError) as error:
failures.append(AuditFailure(uid, str(error)))
return EvaluationAudit(
len(cases), observed, tuple(uid for uid in expected if uid not in seen), tuple(failures), tuple(results)
)
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--tokens", type=Path, required=True)
parser.add_argument("--eval-dump", type=Path, required=True)
parser.add_argument("--output", type=Path, required=True)
parser.add_argument("--uid-source", type=UidSource, choices=list(UidSource), required=True)
args = parser.parse_args()
contents = (args.tokens / "validation.jsonl").read_bytes()
manifest = json.loads((args.tokens / "manifest.json").read_text())
digest = hashlib.sha256(contents).hexdigest()
if manifest["status"] != "local-token-roundtrip-passed" or digest != manifest["hashes"]["validation"]:
raise ValueError("Validation cohort differs from the immutable token audit")
cases = [json.loads(line) for line in contents.splitlines()]
expected_count = sum(count for key, count in manifest["counts"].items() if key.startswith("validation/"))
if len(cases) != expected_count or len({case["case_id"] for case in cases}) != len(cases):
raise ValueError("Validation coverage or case identities differ from the token audit")
if any(case["split"] != "validation" for case in cases):
raise ValueError("Training cases cannot enter the validation audit")
dump = args.eval_dump.read_bytes()
audit = audit_evaluation(cases, (json.loads(line) for line in dump.splitlines()), uid_source=args.uid_source)
report = {
"uid_source": args.uid_source,
"validation_sha256": digest,
"eval_dump_sha256": hashlib.sha256(dump).hexdigest(),
**audit.summary(),
}
with args.output.open("x") as output:
json.dump(report, output, indent=2)
output.write("\n")
print(json.dumps({"complete": audit.complete, "scored": len(audit.results), "expected": audit.expected}))
raise SystemExit(0 if audit.complete else 1)
if __name__ == "__main__":
main()