Datasets:
File size: 9,286 Bytes
44353e7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 | # 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()
|