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